15000字、6个代码案例、5个原理图让你彻底搞懂Synchronized ...

Synchronized

本篇文章将围绕synchronized关键字，使用大量图片、案例深入浅出的描述CAS、synchronized Java层面和C++层面的实现、锁升级的原理、源码等
大概观看时间17分钟
可以带着几个问题去查看本文，如果认真看完，问题都会迎刃而解：
1、synchronized是怎么使用的？在Java层面是如何实现？
2、CAS是什么？能带来什么好处？又有什么缺点？
3、mark word是什么？跟synchronized有啥关系？
4、synchronized的锁升级优化是什么？在C++层面如何实现？
5、JDK 8 中轻量级锁CAS失败到底会不会自旋？
6、什么是object monitor？wait/notify方法是如何实现的？使用synchronized时，线程阻塞后是如何在阻塞队列中排序的？
...
synchronized Java层面实现

synchronized作用在代码块或方法上，用于保证并发环境下的同步机制
任何线程遇到synchronized都要先获取到锁才能执行代码块或方法中的操作
在Java中每个对象有一个对应的monitor对象（监视器），当获取到A对象的锁时，A对象的监视器对象中有个字段会指向当前线程，表示这个线程获取到A对象的锁（详细原理后文描述）
synchronized可以作用于普通对象和静态对象，当作用于静态对象、静态方法时，都是去获取其对应的Class对象的锁
synchronized作用在代码块上时，会使用monitorentry和monitorexit字节码指令来标识加锁、解锁
synchronized作用在方法上时，会在访问标识上加上synchronized
指令中可能出现两个monitorexit指令是因为当发生异常时，会自动执行monitorexit进行解锁
正常流程是PC 12-14，如果在此期间出现异常就会跳转到PC 17，最终在19执行monitorexit进行解锁

1.         Object obj = new Object();
2.         synchronized (obj) {
4.         }

复制代码

在上篇文章中我们说过原子性、可见性以及有序性
synchronized加锁解锁的字节码指令使用屏障，加锁时共享内存从主内存中重新读取，解锁前把工作内存数据写回主内存以此来保证可见性
由于获取到锁才能执行相当于串行执行，也就保证原子性和有序性，需要注意的是加锁与解锁之间的指令还是可以重排序的
CAS

为了更好的说明synchronized原理和锁升级，我们先来聊聊CAS
在上篇文章中我们说过，volatile不能保证复合操作的原子性，使用synchronized方法或者CAS能够保证复合操作原子性
那什么是CAS呢？
CAS全称 Compare And Swap 比较并交换，读取数据后要修改时用读取的数据和地址上的值进行比较，如果相等那就将地址上的值替换为目标值，如果不相等，通常会重新读取数据再进行CAS操作，也就是失败重试
synchronized加锁是一种悲观策略，每次遇到时都认为会有并发问题，要先获取锁才操作
而CAS是一种乐观策略，每次先大胆的去操作，操作失败（CAS失败）再使用补偿措施（失败重试）
CAS与失败重试（循环）的组合构成乐观锁或者说自旋锁（循环尝试很像在自我旋转）
并发包下的原子类，依靠Unsafe大量使用CAS操作，比如AtomicInteger的自增

1.     public final int getAndIncrement() {
2.         return unsafe.getAndAddInt(this, valueOffset, 1);
3.     }
5.     //var1是调用方法的对象，var2是需要读取/修改的值在这个对象上的偏移量，var4是自增1
6.     public final int getAndAddInt(Object var1, long var2, int var4) {
7.         int var5;
8.         do {
9.             //var5是通过对象和字段偏移量获取到字段最新值
10.             var5 = this.getIntVolatile(var1, var2);
11.             //cas：var1,var2找到字段的值 与 var5比较，相等就替换为 var5+var4
12.         } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
13.         return var5;
14.     }

复制代码

CAS只能对一个变量进行操作，如果要对多个变量进行操作，那么只能对外封装一层（将多个变量封装为新对象的字段），再使用原子类中的AtomicReference
不知各位同学有没有发现，CAS的流程有个bug，就是在读数据与比较数据之间，如果数据从A被改变到B，再改变到A，那么CAS也能执行成功
这种场景有的业务能够接受，有的业务无法接受，这就是所谓的ABA问题
而解决ABA问题的方式比较简单，可以再比较时附加一个自增的版本号，JDK也提供解决ABA问题的原子类AtomicStampedReference
CAS能够避免线程阻塞，但如果一直失败就会一直循环，增加CPU的开销，CAS失败后重试的次数/时长不好评估
因此CAS操作适用于竞争小的场景，用CPU空转的开销来换取线程阻塞挂起/恢复的开销
锁升级

早期版本的synchronized会将获取不到锁的线程直接挂起，性能不好
JDK 6 时对synchronized的实现进行优化，也就是锁升级
锁的状态可以分为无锁、偏向锁、轻量级锁、重量级锁
可以暂时把重量级锁理解为早期获取不到锁就让线程挂起，新的优化也就是轻量级锁和偏向锁
mark word

为了更好的说明锁升级，我们先来聊聊Java对象头中的mark word
我们下面的探究都是围绕64位的虚拟机
Java对象的内存由mark word、klass word、如果是数组还要记录长度、实例数据（字段）、对其填充（填充到8字节倍数）组成
mark word会记录锁状态，在不同锁状态的情况下记录的数据也不同
下面这个表格是从无锁到重量级锁mark word记录的内容

1. |----------------------------------------------------------------------|--------|--------|
2. | unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1  | lock:2 | 无锁   
3. |----------------------------------------------------------------------|--------|--------|
4. |  thread:54 |         epoch:2      | unused:1 | age:4 | biased_lock:1 | lock:2 | 偏向锁
5. |----------------------------------------------------------------------|--------|--------|
6. |                     ptr_to_lock_record:62                            | lock:2 | 轻量级锁
7. |----------------------------------------------------------------------|--------|--------|
8. |                     ptr_to_heavyweight_monitor:62                    | lock:2 | 重量级锁
9. |----------------------------------------------------------------------|--------|--------|

复制代码

unused 表示还没使用
identity_hashcode 用于记录一致性哈希
age 用于记录GC年龄
biased_lock 标识是否使用偏向锁，0表示未开启，1表示开启
lock 用于标识锁状态标志位，01无锁或偏向锁、00轻量级锁、10重量级锁
thread 用于标识偏向的线程
epoch 记录偏向的时间戳
ptr_to_lock_record 记录栈帧中的锁记录（后文介绍）
ptr_to_heavyweight_monitor 记录获取重量级锁的线程
jol查看mark word

比较熟悉mark word的同学可以跳过
了解mark word后再来熟悉下不同锁状态下的mark word，我使用的是jol查看内存

1.       
2.         <dependency>
3.             <groupId>org.openjdk.jol</groupId>
4.             <artifactId>jol-core</artifactId>
5.             <version>0.12</version>
6.         </dependency>

复制代码

无锁

各位同学实验时的mark word可能和我注释中的不同，我们主要查看锁标识的值和是否启用偏向锁

1.     public void noLock() {
2.         Object obj = new Object();
3.         //mark word  00000001 被unused:1，age:4，biased_lock:1，lock:2使用，001表示0未启用偏向锁,01表示无锁
4.         //01 00 00 00  (00000001 00000000 00000000 00000000)
5.         //00 00 00 00  (00000000 00000000 00000000 00000000)
6.         ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
7.         System.out.println(objClassLayout.toPrintable());
9.         //计算一致性哈希后
10.         //01 b6 ce a8
11.         //6a 00 00 00
12.         obj.hashCode();
13.         System.out.println(objClassLayout.toPrintable());
15.         //进行GC 查看GC年龄 0 0001 0 01 前2位表示锁状态01无锁，第三位biased_lock为0表示未启用偏向锁，后续四位则是GC年龄age 1
16.         //09 b6 ce a8 (00001001 10110110 11001110 10101000)
17.         //6a 00 00 00 (01101010 00000000 00000000 00000000)
18.         System.gc();
19.         System.out.println(objClassLayout.toPrintable());
20.     }

复制代码

轻量级锁

1.     public void lightLockTest() throws InterruptedException {
2.         Object obj = new Object();
3.         ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
4.         //1334729950
5.         System.out.println(obj.hashCode());
6.         //0 01 无锁
7.         //01 4e c0 d5 (00000001 01001110 11000000 11010101)
8.         //6a 00 00 00 (01101010 00000000 00000000 00000000)
9.         System.out.println(Thread.currentThread().getName() + ":");
10.         System.out.println(objClassLayout.toPrintable());
13.         Thread thread1 = new Thread(() -> {
14.             synchronized (obj) {
15.                 // 110110 00 中的00表示轻量级锁其他62位指向拥有锁的线程
16.                 //d8 f1 5f 1d (11011000 11110001 01011111 00011101)
17.                 //00 00 00 00 (00000000 00000000 00000000 00000000)
18.                 System.out.println(Thread.currentThread().getName() + ":");
19.                 System.out.println(objClassLayout.toPrintable());
21.                 //1334729950
22.                 //无锁升级成轻量级锁后 hashcode未变 对象头中没存储hashcode 只存储拥有锁的线程
23.                 //（实际上mark word内容被存储到lock record中，所以hashcode也被存储到lock record中）
24.                 System.out.println(obj.hashCode());
25.             }
26.         }, "t1");
28.         thread1.start();
29.         //等待t1执行完 避免 发生竞争
30.         thread1.join();
32.         //轻量级锁 释放后 mark word 恢复成无锁 存储哈希code的状态
33.         //01 4e c0 d5 (00000001 01001110 11000000 11010101)
34.         //6a 00 00 00 (01101010 00000000 00000000 00000000)
35.         System.out.println(Thread.currentThread().getName() + ":");
36.         System.out.println(objClassLayout.toPrintable());
38.         Thread thread2 = new Thread(() -> {
39.             synchronized (obj) {
40.                 //001010 00 中的00表示轻量级锁其他62位指向拥有锁的线程
41.                 //28 f6 5f 1d (00101000 11110110 01011111 00011101)
42.                 //00 00 00 00 (00000000 00000000 00000000 00000000)
43.                 System.out.println(Thread.currentThread().getName() + ":");
44.                 System.out.println(objClassLayout.toPrintable());
45.             }
46.         }, "t2");
47.         thread2.start();
48.         thread2.join();
49.     }

复制代码

偏向锁

1.     public void biasedLockTest() throws InterruptedException {
2.         //延迟让偏向锁启动
3.         Thread.sleep(5000);
5.         Object obj = new Object();
6.         ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
8.         //1 01 匿名偏向锁 还未设置偏向线程
9.         //05 00 00 00 (00000101 00000000 00000000 00000000)
10.         //00 00 00 00 (00000000 00000000 00000000 00000000)
11.         System.out.println(Thread.currentThread().getName() + ":");
12.         System.out.println(objClassLayout.toPrintable());
14.         synchronized (obj) {
15.             //偏向锁 记录 线程地址
16.             //05 30 e3 02 (00000101 00110000 11100011 00000010)
17.             //00 00 00 00 (00000000 00000000 00000000 00000000)
18.             System.out.println(Thread.currentThread().getName() + ":");
19.             System.out.println(objClassLayout.toPrintable());
20.         }
22.         Thread thread1 = new Thread(() -> {
23.             synchronized (obj) {
24.                 //膨胀为轻量级 0 00 0未启用偏向锁,00轻量级锁
25.                 //68 f4 a8 1d (01101000 11110100 10101000 00011101)
26.                 //00 00 00 00 (00000000 00000000 00000000 00000000)
27.                 System.out.println(Thread.currentThread().getName() + ":");
28.                 System.out.println(objClassLayout.toPrintable());
29.             }
30.         }, "t1");
32.         thread1.start();
33.         thread1.join();
34.     }

复制代码

重量级锁

1.     public void heavyLockTest() throws InterruptedException {
2.         Object obj = new Object();
3.         ClassLayout objClassLayout = ClassLayout.parseInstance(obj);
4.         Thread thread1 = new Thread(() -> {
5.             synchronized (obj) {
6.                 //第一次 00 表示 轻量级锁
7.                 //d8 f1 c3 1e (11011000 11110001 11000011 00011110)
8.                 //00 00 00 00 (00000000 00000000 00000000 00000000)
9.                 System.out.println(Thread.currentThread().getName() + ":");
10.                 System.out.println(objClassLayout.toPrintable());
12.                 //用debug控制t2来竞争
13.                 //第二次打印 变成 10 表示膨胀为重量级锁（t2竞争）  其他62位指向监视器对象
14.                 //fa 21 3e 1a (11111010 00100001 00111110 00011010)
15.                 //00 00 00 00 (00000000 00000000 00000000 00000000)
16.                 System.out.println(Thread.currentThread().getName() + ":");
17.                 System.out.println(objClassLayout.toPrintable());
18.             }
19.         }, "t1");
21.         thread1.start();
23.         Thread thread2 = new Thread(() -> {
24.             synchronized (obj) {
25.                 //t2竞争 膨胀为 重量级锁 111110 10 10为重量级锁
26.                 //fa 21 3e 1a (11111010 00100001 00111110 00011010)
27.                 //00 00 00 00 (00000000 00000000 00000000 00000000)
28.                 System.out.println(Thread.currentThread().getName() + ":");
29.                 System.out.println(objClassLayout.toPrintable());
30.             }
31.         }, "t2");
32.         thread2.start();
34.         thread1.join();
35.         thread2.join();
37.         //10 重量级锁 未发生锁降级
38.         //3a 36 4d 1a (00111010 00110110 01001101 00011010)
39.         //00 00 00 00 (00000000 00000000 00000000 00000000)
40.         System.out.println(Thread.currentThread().getName() + ":");
41.         System.out.println(objClassLayout.toPrintable());
42.     }

复制代码

轻量级锁

轻量级锁的提出是为了减小传统重量级锁使用互斥量（挂起/恢复线程）所产生的开销
面对较少的竞争场景时，获取锁的时间总是短暂的，而挂起线程用户态、内核态的开销比较大，使用轻量级锁减少开销
那么轻量级锁是如何实现的呢？
轻量级锁主要由lock record、mark word、CAS来实现,lock record存储在线程的栈帧中，来记录锁的信息
加锁

查看对象是不是无锁状态，如果对象是无锁状态，会将mark word复制到lock record锁记录中的displaced mark word

然后再尝试使用CAS尝试将mark word中部分内容替换指向这个lock record，如果成功表示获取锁成功

如果对象持有锁，会查看持有锁的线程是不是当前线程，这种可重入的情况下lock record中记录不再是mark word而是null
可重入的情况下，只需要进行自增计数即可，解锁时遇到null的lock record则扣减

如果CAS失败或者持有锁的线程不是当前线程，就会触发锁膨胀
关键代码如下：

1. void ObjectSynchronizer::slow_enter(Handle obj, BasicLock* lock, TRAPS) {
2.   //当前对象的mark word
3.   markOop mark = obj->mark();
4.   assert(!mark->has_bias_pattern(), "should not see bias pattern here");
6.   //如果当前对象是无锁状态
7.   if (mark->is_neutral()) {
8.     //将mark word复制到lock record
9.     lock->set_displaced_header(mark);
10.     //CAS将当前对象的mark word内容替换为指向lock record
11.     if (mark == (markOop) Atomic::cmpxchg_ptr(lock, obj()->mark_addr(), mark)) {
12.       TEVENT (slow_enter: release stacklock) ;
13.       return ;
14.     }
15.   } else
16.   //如果有锁  判断是不是当前线程获取锁
17.   if (mark->has_locker() && THREAD->is_lock_owned((address)mark->locker())) {
18.     assert(lock != mark->locker(), "must not re-lock the same lock");
19.     assert(lock != (BasicLock*)obj->mark(), "don't relock with same BasicLock");
20.     //可重入锁 复制null
21.     lock->set_displaced_header(NULL);
22.     return;
23.   }
25.   //有锁并且获取锁的线程不是当前线程 或者 CAS失败 进行膨胀
26.   lock->set_displaced_header(markOopDesc::unused_mark());
27.   ObjectSynchronizer::inflate(THREAD, obj())->enter(THREAD);
28. }

复制代码

解锁

查看lock record中复制的内容是不是空，是空说明是可重入锁
不为空则查看mark word是否指向lock record，如果指向则CAS尝试将mark word记录指向lock record替换为lock record中的displaced mark word（也就是原来的mark word）
如果mark word不指向lock record 或者 CAS失败了 说明存在竞争，其他线程加锁失败让mark word指向重量级锁，直接膨胀

关键代码如下：

1. void ObjectSynchronizer::fast_exit(oop object, BasicLock* lock, TRAPS) {
2.   assert(!object->mark()->has_bias_pattern(), "should not see bias pattern here");
4.   //获取复制的mark word
5.   markOop dhw = lock->displaced_header();
6.   markOop mark ;
7.   //如果为空 说明是可重入
8.   if (dhw == NULL) {
9.      // Recursive stack-lock.
10.      // Diagnostics -- Could be: stack-locked, inflating, inflated.
11.      mark = object->mark() ;
12.      assert (!mark->is_neutral(), "invariant") ;
13.      if (mark->has_locker() && mark != markOopDesc::INFLATING()) {
14.         assert(THREAD->is_lock_owned((address)mark->locker()), "invariant") ;
15.      }
16.      if (mark->has_monitor()) {
17.         ObjectMonitor * m = mark->monitor() ;
18.         assert(((oop)(m->object()))->mark() == mark, "invariant") ;
19.         assert(m->is_entered(THREAD), "invariant") ;
20.      }
21.      return ;
22.   }
24.   mark = object->mark() ;
26.   //如果mark word指向lock record
27.   if (mark == (markOop) lock) {
28.      assert (dhw->is_neutral(), "invariant") ;
29.      //尝试CAS将指向lock record的mark word替换为原来的内容
30.      if ((markOop) Atomic::cmpxchg_ptr (dhw, object->mark_addr(), mark) == mark) {
31.         TEVENT (fast_exit: release stacklock) ;
32.         return;
33.      }
34.   }
36.   //未指向当前lock record或者CAS失败则膨胀
37.   ObjectSynchronizer::inflate(THREAD, object)->exit (true, THREAD) ;
38. }

复制代码

偏向锁

hotspot开发人员测试，在某些场景下，总是同一个线程获取锁，在这种场景下，希望用更小的开销来获取锁
当开启偏向锁后，如果是无锁状态会将mark word改为偏向某个线程ID，以此标识这个线程获取锁（锁偏向这个线程）
如果正处于偏向锁，遇到竞争可能膨胀为轻量级锁，如果要存储一致性哈希等情况也会膨胀为重量级锁
JDK8默认开启偏向锁，在高版本JDK默认不开启偏向锁，可能因为偏向锁的维护超过收益，我们也不深入进行研究
重量级锁

object monitor

使用object monitor对象来实现重量级锁
object monitor中使用一些字段记录信息，比如：object字段用于记录锁的那个对象，header字段用于记录锁的那个对象的mark word、owner字段用于记录持有锁的线程
object monitor使用阻塞队列来存储竞争不到锁的线程，使用等待队列来存储调用wait进入等待状态的线程
阻塞队列和等待队列类比着并发包下的AQS和Condition
object monitor使用cxq栈和entry list队列来实现阻塞队列，其中cxq栈中存储有竞争的线程，entry list存储已经竞争失败较稳定的线程；使用wait set实现等待队列
当线程调用wait时，进入wait set等待队列
而调用notify时，只是将等待队列的队头节点加入cxq，并没有唤醒该线程去竞争
真正的唤醒线程是在释放锁时，去稳定的队列entry list中唤醒队头节点去竞争，而此时被唤醒的节点并不一定能抢到锁，因为线程进入cxq时还会通过自旋来抢锁，以此来实现非公平锁
如果稳定的entry list中没有存储线程，会将cxq栈中存储的线程全存储到entry list中再去唤醒，此时越晚进入cxq的线程反而会越早被唤醒（cxq栈先进后出）
其实实现与AQS类似，来看这样一段代码：
t1-t6获取同一把锁，使用t1线程进行阻塞一会，后续t2-t6线程按照顺序启动，由于自转获取不到锁，它们会被依次放入cxq：t2,t3,t4,t5,t6
在t1释放锁时，由于entry list中没有线程，于是将cxq中的线程存入entry list：t6,t5,t4,t3,t2，再唤醒t6
由于后续没有线程进行竞争，因此最终执行顺序为t1,t6,t5,t4,t3,t2

1. Object obj = new Object();
2. new Thread(() -> {
3.     synchronized (obj) {
4.         try {
5.             //输入阻塞
6.             //阻塞的目的是让  其他线程自旋完未获取到锁，进入cxq栈
7.             System.in.read();
8.         } catch (IOException e) {
9.             e.printStackTrace();
10.         }
11.         System.out.println(Thread.currentThread().getName() + " 获取到锁");
12.     }
13. }, "t1").start();
15. //sleep控制线程阻塞的顺序
16. Thread.sleep(50);
17. new Thread(() -> {
18.     synchronized (obj) {
19.         System.out.println(Thread.currentThread().getName() + " 获取到锁");
20.     }
21. }, "t2").start();
23. Thread.sleep(50);
24. new Thread(() -> {
25.     synchronized (obj) {
26.         System.out.println(Thread.currentThread().getName() + " 获取到锁");
27.     }
28. }, "t3").start();
30. Thread.sleep(50);
31. new Thread(() -> {
32.     synchronized (obj) {
33.         System.out.println(Thread.currentThread().getName() + " 获取到锁");
34.     }
35. }, "t4").start();
37. Thread.sleep(50);
38. new Thread(() -> {
39.     synchronized (obj) {
40.         System.out.println(Thread.currentThread().getName() + " 获取到锁");
41.     }
42. }, "t5").start();
44. Thread.sleep(50);
45. new Thread(() -> {
46.     synchronized (obj) {
47.         System.out.println(Thread.currentThread().getName() + " 获取到锁");
48.     }
49. }, "t6").start();

复制代码

大致了解了下object monitor，我们再来看看膨胀和自旋
膨胀

在膨胀时会有四种状态，分别是
inflated 已膨胀：mark word锁标志为10（2）说明已膨胀，直接返回object monitor
inflation in progress 膨胀中：如果已经有其他线程在膨胀了，就等待一会循环后查看状态进入已膨胀的逻辑
stack-locked 轻量级锁膨胀
neutral 无锁膨胀
轻量级锁和无锁膨胀逻辑差不多，都是需要创建object monitor对象，并且set一些属性进去（比如：mark word、锁的哪个对象、哪个线程持有锁...），最后再使用CAS去替换mark word指向object monitor

1. ObjectMonitor * ATTR ObjectSynchronizer::inflate (Thread * Self, oop object) {
3.   for (;;) {
4.       const markOop mark = object->mark() ;
5.       assert (!mark->has_bias_pattern(), "invariant") ;
7.       // The mark can be in one of the following states:
8.       // *  Inflated     - just return
9.       // *  Stack-locked - coerce it to inflated
10.       // *  INFLATING    - busy wait for conversion to complete
11.       // *  Neutral      - aggressively inflate the object.
12.       // *  BIASED       - Illegal.  We should never see this
14.       // CASE: inflated
15.       // 已膨胀:查看 mark word 后两位是否为2  是则膨胀完 返回monitor对象
16.       if (mark->has_monitor()) {
17.           ObjectMonitor * inf = mark->monitor() ;
18.           assert (inf->header()->is_neutral(), "invariant");
19.           assert (inf->object() == object, "invariant") ;
20.           assert (ObjectSynchronizer::verify_objmon_isinpool(inf), "monitor is invalid");
21.           return inf ;
22.       }
24.       // CASE: inflation in progress - inflating over a stack-lock.
25.       // 膨胀中: 等待一会 再循环 从膨胀完状态退出
26.       if (mark == markOopDesc::INFLATING()) {
27.          TEVENT (Inflate: spin while INFLATING) ;
28.          ReadStableMark(object) ;
29.          continue ;
30.       }
32.       // CASE: stack-locked
33.       //轻量级锁膨胀
34.       if (mark->has_locker()) {
35.           //创建ObjectMonitor
36.           ObjectMonitor * m = omAlloc (Self) ;
37.           m->Recycle();
38.           m->_Responsible  = NULL ;
39.           m->OwnerIsThread = 0 ;
40.           m->_recursions   = 0 ;
41.           m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;   // Consider: maintain by type/class
42.           //cas将mark word替换指向ObjectMonitor
43.           markOop cmp = (markOop) Atomic::cmpxchg_ptr (markOopDesc::INFLATING(), object->mark_addr(), mark) ;         
44.           //cas 失败 则说明其他线程膨胀成功，删除当前monitor 退出
45.           if (cmp != mark) {
46.              omRelease (Self, m, true) ;
47.              continue ;       // Interference -- just retry
48.           }
49.           markOop dmw = mark->displaced_mark_helper() ;
50.           assert (dmw->is_neutral(), "invariant") ;
52.           //成功 设置mark word
53.           m->set_header(dmw) ;
54.           //设置持有锁的线程
55.           m->set_owner(mark->locker());
56.           //设置锁的是哪个对象
57.           m->set_object(object);
58.           guarantee (object->mark() == markOopDesc::INFLATING(), "invariant") ;
59.           //修改mark word对象头信息 锁状态 2
60.           object->release_set_mark(markOopDesc::encode(m));
61.           if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
62.           TEVENT(Inflate: overwrite stacklock) ;
63.           if (TraceMonitorInflation) {
64.             if (object->is_instance()) {
65.               ResourceMark rm;
66.               tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
67.                 (void *) object, (intptr_t) object->mark(),
68.                 object->klass()->external_name());
69.             }
70.           }
71.           return m ;
72.       }
74.       // CASE: neutral
75.       //无锁膨胀 与轻量级锁膨胀类似，也是创建monitor对象并注入属性，只是很多属性为空
76.       assert (mark->is_neutral(), "invariant");
78.       ObjectMonitor * m = omAlloc (Self) ;
79.       m->Recycle();
80.       m->set_header(mark);
81.       m->set_owner(NULL);
82.       m->set_object(object);
83.       m->OwnerIsThread = 1 ;
84.       m->_recursions   = 0 ;
85.       m->_Responsible  = NULL ;
86.       m->_SpinDuration = ObjectMonitor::Knob_SpinLimit ;       // consider: keep metastats by type/class
87.       //cas 更新 mark word 失败循环等待  成功返回
88.       if (Atomic::cmpxchg_ptr (markOopDesc::encode(m), object->mark_addr(), mark) != mark) {
89.           m->set_object (NULL) ;
90.           m->set_owner  (NULL) ;
91.           m->OwnerIsThread = 0 ;
92.           m->Recycle() ;
93.           omRelease (Self, m, true) ;
94.           m = NULL ;
95.           continue ;
96.       }
97.      
98.       if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc() ;
99.       TEVENT(Inflate: overwrite neutral) ;
100.       if (TraceMonitorInflation) {
101.         if (object->is_instance()) {
102.           ResourceMark rm;
103.           tty->print_cr("Inflating object " INTPTR_FORMAT " , mark " INTPTR_FORMAT " , type %s",
104.             (void *) object, (intptr_t) object->mark(),
105.             object->klass()->external_name());
106.         }
107.       }
108.       return m ;
109.   }
110. }

复制代码

自旋

膨胀过后，在最终挂起前会进行固定自旋和自适应自旋
固定自旋默认10+1次
自适应自旋一开始5000次，如果最近竞争少获取到锁就将自旋次数调大，如果最近竞争大获取不到锁就将自旋次数调小

1. int ObjectMonitor::TrySpin_VaryDuration (Thread * Self) {
3.     // Dumb, brutal spin.  Good for comparative measurements against adaptive spinning.
4.     int ctr = Knob_FixedSpin ;
5.     if (ctr != 0) {
6.         while (--ctr >= 0) {
7.             if (TryLock (Self) > 0) return 1 ;
8.             SpinPause () ;
9.         }
10.         return 0 ;
11.     }
12.     //先进行固定11自旋次数 获取到锁返回，没获取到空转
13.     for (ctr = Knob_PreSpin + 1; --ctr >= 0 ; ) {
14.       if (TryLock(Self) > 0) {
15.         // Increase _SpinDuration ...
16.         // Note that we don't clamp SpinDuration precisely at SpinLimit.
17.         // Raising _SpurDuration to the poverty line is key.
18.         int x = _SpinDuration ;
19.         if (x < Knob_SpinLimit) {
20.            if (x < Knob_Poverty) x = Knob_Poverty ;
21.            _SpinDuration = x + Knob_BonusB ;
22.         }
23.         return 1 ;
24.       }
25.       SpinPause () ;
26.     }
27.    
28.     //自适应自旋 一开始5000 如果成功认为此时竞争不大 自旋获取锁成功率高 增加重试次数 如果失败则减少
29.     //...
30. }   

复制代码

总结

本篇文章围绕synchronized，深入浅出的描述CAS、synchronized在Java层面和C++层面的实现、锁升级原理、案例、源码等
synchronized用于并发下的需要同步的场景，使用它可以满足原子性、可见性以及有序性，它可以作用在普通对象和静态对象，作用于静态对象时是去获取其对应的Class对象的锁
synchronized作用在代码块上时，使用monitorentry、monitorexit字节码指令来标识加锁、解锁；作用在方法上时，在访问标识加锁synchronized关键字，虚拟机隐式使用monitorentry、monitorexit
CAS 比较并替换，常与重试机制实现乐观锁/自旋锁，优点是能够在竞争小的场景用较小的开销取代线程挂起，但带来ABA问题、无法预估重试次数空转CPU的开销等问题
轻量级锁的提出是为了在交替执行/竞争少的场景，用更小的开销取代互斥量；使用CAS和lock record实现
轻量级锁加锁时，如果是无锁则复制mark word到lock record中，再CAS将对象mark word替换为指向该lock record，失败则膨胀；如果已经持有锁则判断持有锁的线程是不是当前线程，是则累加次数，不是当前线程则膨胀
轻量级锁解锁时，查看lock record复制的是不是null，是则说明是可重入锁，次数减一；不是则CAS把复制过来的mark word替换回去，如果替换失败说明其他线程竞争，mark word已经指向object monitor，去指向重量级锁的释放
偏向锁的提出是为了在经常一条线程执行的场景下，用更小的开销来取代CAS的开销，只不过高版本不再默认开启
重量级锁由object monitor来实现，object monitor中使用cxq、entry list来构成阻塞队列，wait set来构成等待队列
当执行wait方法时，线程构建为节点加入wait set；当执行notify方法时，将wait set队头节点加入cxq，在释放锁时才去唤醒entry list队头节点竞争锁，即使没抢到锁构建为节点加入cxq时还会自旋，因此并不是entry list队头节点就一定能抢到锁，以此来实现非公平锁；当entry list为空时，将cxq栈中的节点加入entry list队列（后进入cxq的节点会被先唤醒）
在膨胀为重量级锁时有四种情况，如果状态为已膨胀则直接返回object monitor对象；如果状态为膨胀中，说明其他线程正在膨胀，等待会，下次循环进入已膨胀的逻辑；如果状态为轻量级锁膨胀或无锁膨胀，都会去创建object monitor对象，set一些重要属性，并CAS去将mark word替换为指向该object monitor
重量级锁在最终挂起前会进行固定自旋和自适应自旋（最近竞争小就增加自旋次数；竞争多就减少自旋次数）
最后（不要白嫖，一键三连求求拉~）

本篇文章被收入专栏 由点到线，由线到面，深入浅出构建Java并发编程知识体系，感兴趣的同学可以持续关注喔
本篇文章笔记以及案例被收入 gitee-StudyJava、 github-StudyJava 感兴趣的同学可以stat下持续关注喔~
案例地址：
Gitee-JavaConcurrentProgramming/src/main/java/B_synchronized
Github-JavaConcurrentProgramming/src/main/java/B_synchronized
有什么问题可以在评论区交流，如果觉得菜菜写的不错，可以点赞、关注、收藏支持一下~
关注菜菜，分享更多干货，公众号：菜菜的后端私房菜

本文由博客一文多发平台 OpenWrite 发布！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！