[TOC] ## **Synchronized**同步锁 synchronized 它可以把任意一个非 NULL 的对象当作锁。他属于独占式的悲观锁,同时属于可重 入锁。 ### **Synchronized作用范围** 1. 作用于方法时,锁住的是对象的实例(this); 2. 当作用于静态方法时,锁住的是 Class 实例,又因为 Class 的相关数据存储在永久带 PermGen (jdk1.8 则是 metaspace ),永久带是全局共享的,因此静态方法锁相当于类的一个全局锁, 会锁所有调用该方法的线程; 3. synchronized 作用于一个对象实例时,锁住的是所有以该对象为锁的代码块。它有多个队列, 当多个线程一起访问某个对象监视器的时候,对象监视器会将这些线程存储在不同的容器中。 ### **Synchronized核心组件** 1)**WaitSet**:哪些调用wait方法被阻塞的线程被放置在这里; 2)**Contention List**:竞争队列,所有请求锁的线程首先被放在这个竞争队列中; 3)**Entry List**:Contention List 中那些有资格成为候选资源的线程被移动到 Entry List 中; 4)**OnDeck** :任意时刻,最多只有一个线程正在竞争锁资源,该线程被成为 OnDeck; 5)**Owner**:当前已经获取到所资源的线程被称为Owner; 6)**!Owner**:当前释放锁的线程。 ### **Synchronized实现** :-: ![](https://box.kancloud.cn/d8a98f76177f4347faca253d8a61da1f_570x252.jpg) 1. JVM 每次从队列的尾部取出一个数据用于锁竞争候选者( OnDeck ),但是并发情况下,ContentionList 会被大量的并发线程进行 CAS 访问,为了降低对尾部元素的竞争,JVM 会将一部分线程移动到 EntryList 中作为候选竞争线程。 <br> 2. Owner 线程会在 unlock 时,将 ContentionList 中的部分线程迁移到 EntryList 中,并指定EntryList 中的某个线程为 OnDeck 线程(一般是最先进去的那个线程)。 <br> 3. Owner 线程并不直接把锁传递给 OnDeck 线程,而是把锁竞争的权利交给 OnDeck ,OnDeck 需要重新竞争锁。这样虽然牺牲了一些公平性,但是能极大的提升系统的吞吐量,在JVM 中,也把这种选择行为称之为“竞争切换”。 <br> 4. OnDeck 线程获取到锁资源后会变为 Owner 线程,而没有得到锁资源的仍然停留在 EntryList中。如果 Owner 线程被 wait 方法阻塞,则转移到 WaitSet 队列中,直到某个时刻通过 notify或者 notifyAll 唤醒,会重新进去 EntryList 中。 <br> 5. 处于 ContentionList 、 EntryList 、WaitSet 中的线程都处于阻塞状态,该阻塞是由操作系统来完成的(Linux 内核下采用 pthread\_mutex\_lock 内核函数实现的)。 <br> 6. Synchronized 是**非公平锁**。 Synchronized 在线程进入 ContentionList 时,等待的线程会先尝试自旋获取锁,如果获取不到就进入 ContentionList,这明显对于已经进入队列的线程是不公平的,还有一个不公平的事情就是自旋获取锁的线程还可能直接抢占 OnDeck 线程的锁资源。 参考:[https://blog.csdn.net/zqz\_zqz/article/details/70233767](http://https:/blog.csdn.net/zqz_zqz/article/details/70233767) <br> 7. 每个对象都有个 monitor 对象,加锁就是在竞争 monitor 对象,代码块加锁是在前后分别加上 monitorenter 和 monitorexit 指令来实现的,方法加锁是通过一个标记位来判断的 <br> 8. synchronized是一个**重量级**操作,需要调用操作系统相关接口,性能是低效的,有可能给线程加锁消耗的时间比有用操作消耗的时间更多。 <br> 9. Java1.6 ,synchronized 进行了很多的优化,有适应自旋、锁消除、锁粗化、轻量级锁及偏向锁等,效率有了本质上的提高。在之后推出的 Java1.7 与 1.8 中,均对该关键字的实现机理做了优化。引入了偏向锁和轻量级锁。都是在对象头中有标记位,不需要经过操作系统加锁。 <br> 10.锁可以从偏向锁升级到轻量级锁,再升级到重量级锁。这种升级过程叫做锁膨胀; <br> 11.JDK 1.6 中默认是开启偏向锁和轻量级锁,可以通过 -XX:-UseBiasedLocking 来禁用偏向锁。 <br> ### **synchronized用法** **1\. 同步一个代码块** ~~~java public void func() { synchronized (this) { // ... } } ~~~ 它只作用于同一个对象,如果调用两个对象上的同步代码块,就不会进行同步。 对于以下代码,使用 ExecutorService 执行了两个线程,由于调用的是同一个对象的同步代码块,因此这两个线程会进行同步,当一个线程进入同步语句块时,另一个线程就必须等待。 ~~~java public class SynchronizedExample { public void func1() { synchronized (this) { for (int i = 0; i < 10; i++) { System.out.print(i + " "); } } } } ~~~ ~~~java public static void main(String[] args) { SynchronizedExample e1 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(() -> e1.func1()); executorService.execute(() -> e1.func1()); } ~~~ ~~~java 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 ~~~ 对于以下代码,两个线程调用了不同对象的同步代码块,因此这两个线程就不需要同步。从输出结果可以看出,两个线程交叉执行。 ~~~java public static void main(String[] args) { SynchronizedExample e1 = new SynchronizedExample(); SynchronizedExample e2 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(() -> e1.func1()); executorService.execute(() -> e2.func1()); } ~~~ ~~~ 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 ~~~ **2\. 同步一个方法** ~~~java public synchronized void func () { // ... } ~~~ 它和同步代码块一样,作用于同一个对象。 **3\. 同步一个类** ~~~java public void func() { synchronized (SynchronizedExample.class) { // ... } } ~~~ 作用于整个类,也就是说两个线程调用同一个类的不同对象上的这种同步语句,也会进行同步。 ~~~java public class SynchronizedExample { public void func2() { synchronized (SynchronizedExample.class) { for (int i = 0; i < 10; i++) { System.out.print(i + " "); } } } } ~~~ ~~~java public static void main(String[] args) { SynchronizedExample e1 = new SynchronizedExample(); SynchronizedExample e2 = new SynchronizedExample(); ExecutorService executorService = Executors.newCachedThreadPool(); executorService.execute(() -> e1.func2()); executorService.execute(() -> e2.func2()); } ~~~ ~~~ 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 ~~~ **4\. 同步一个静态方法** * 非静态同步函数的锁是:this * 静态的同步函数的锁是:字节码对象 ~~~java public synchronized static void fun() { // ... } ~~~ 作用于整个类。