synchronized 底层如何实现？什么是锁升级、降级？
synchronized 代码块是由一对 monitorenter/monitorexit 指令实现的，Monitor 对象是同步的基本实现单元。
在Java6之前， Monitor的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作。现代的（ Oracle）JDK中，JVM对此进行了大刀阔斧地改进，提供了三种不同的 Monitor 实现，也就是常说的三种不同的锁：偏斜锁（ Biased Locking）、轻量级锁和重量级锁，大大改进了其性能。
什么是锁升级，降级？
所谓的锁升级、降级，就是 JVM 优化 synchronized 运行的机制，当 JVM 监测到不同的竞争状况是，会自动切换到不同的锁实现。这种切换就是锁的升级、降级。
对象的结构
说偏向锁之前，需要理解对象的结构，对象由多部分构成的，对象头，属性字段、补齐区域等。所谓补齐区域是指如果对象总大小不是4字节的整数倍，会填充上一段内存地址使之成为整数倍。
偏向锁又和对象头密切相关，对象头这部分在对象的最前端，包含两部分或者三部分：Mark Words、Klass Words，如果对象是一个数组，那么还可能包含第三部分：数组的长度。
- Klass Word里面存的是一个地址，占32位或64位，是一个指向当前对象所属于的类的地址，可以通过这个地址获取到它的元数据信息。
- Mark Word需要重点说一下，这里面主要包含对象的哈希值、年龄分代、hashcode、锁标志位等。
如果应用的对象过多，使用64位的指针将浪费大量内存。64位的JVM比32位的JVM多耗费50%的内存。我们现在使用的64位 JVM会默认使用选项 +UseCompressedOops 开启指针压缩，将指针压缩至32位。
以64位操作系统为例，对象头存储内容图例
|--------------------------------------------------------------------------------------------------------------| | Object Header (128 bits) | |--------------------------------------------------------------------------------------------------------------| | Mark Word (64 bits) | Klass Word (64 bits) | |--------------------------------------------------------------------------------------------------------------| | unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 | OOP to metadata object | 无锁 |----------------------------------------------------------------------|--------|------------------------------| | thread:54 | epoch:2 | unused:1 | age:4 | biased_lock:1 | lock:2 | OOP to metadata object | 偏向锁 |----------------------------------------------------------------------|--------|------------------------------| | ptr_to_lock_record:62 | lock:2 | OOP to metadata object | 轻量锁 |----------------------------------------------------------------------|--------|------------------------------| | ptr_to_heavyweight_monitor:62 | lock:2 | OOP to metadata object | 重量锁 |----------------------------------------------------------------------|--------|------------------------------| | | lock:2 | OOP to metadata object | GC |--------------------------------------------------------------------------------------------------------------|
对象头中的信息如何理解呢，举个例子
从该对象头中分析加锁信息，MarkWordk为0x0000700009b96910，二进制为0xb00000000 00000000 01111111 11110000 11001000 00000000 01010011 11101010。倒数第三位为"0"，说明不是偏向锁状态，倒数两位为"10"，因此，是重量级锁状态，那么前面62位就是指向互斥量的指针。
| basied_lock | lock | 状态 |
| 0 | 01 | 无锁 |
| 1 | 01 | 偏向锁 |
| 0 | 00 | 轻量级锁 |
| 0 | 10 | 重量级锁 |
| 0 | 11 | GC标记 |
- age：Java GC标记位对象年龄。
- identity_hashcode：对象标识Hash码，采用延迟加载技术。当对象使用HashCode()计算后，并会将结果写到该对象头中。当对象被锁定时，该值会移动到线程Monitor中。
- thread：持有偏向锁的线程ID和其他信息。这个线程ID并不是JVM分配的线程ID号，和Java Thread中的ID是两个概念。
- epoch：偏向时间戳。
- ptr_to_lock_record：指向栈中锁记录的指针。
- ptr_to_heavyweight_monitor：指向线程Monitor的指针。
无锁
A a = new A(); System.out.println(ClassLayout.parseInstance(a).toPrintable());
可以看到最后 00000001 basied_lock = 0, lock =01 表示无锁
JavaThread.synchronizestructure.A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 43 c0 00 20 (01000011 11000000 00000000 00100000) (536920131) 12 1 boolean A.flag false 13 3 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 3 bytes external = 3 bytes total
偏斜锁
当没有竞争出现时，默认使用偏斜锁。JVM 会利用 CAS 操作在对象头上的 Mark Word 部分设置线程 ID ，以表示对象偏向当前线程。所以并不涉及真正的互斥锁，这样做的假设是基于在很多应用场景中，大部分对象生命周期中最多会被一个线程锁定，使用偏斜锁可以降低无竟争开销。测试代码：
Thread.sleep(5000); A a = new A(); synchronized (a) { System.out.println(ClassLayout.parseInstance(a).toPrintable()); }
运行结果：
JavaThread.synchronizestructure.A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 28 8d 02 (00000101 00101000 10001101 00000010) (42805253) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 43 c0 00 20 (01000011 11000000 00000000 00100000) (536920131) 12 1 boolean A.flag false 13 3 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 3 bytes external = 3 bytes total
00000101 中 basied_lock = 1, lock =01 表示偏斜锁
轻量级锁
thread1中依旧输出偏向锁，主线程获取对象A时，thread1虽然已经退出同步代码块，但主线程和thread1仍然为锁的交替竞争关系。故此时主线程输出结果为轻量级锁。测试代码：
Thread.sleep(5000); A a = new A(); Thread thread1= new Thread(){ @Override public void run() { synchronized (a){ System.out.println("thread1 locking"); System.out.println(ClassLayout.parseInstance(a).toPrintable()); //偏向锁 } } }; thread1.start(); thread1.join(); Thread.sleep(10000); synchronized (a){ System.out.println("main locking"); System.out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁 } }
运行结果：
JavaThread.synchronizestructure.A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 05 40 e9 19 (00000101 01000000 11101001 00011001) (434716677) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) a0 c0 00 20 (10100000 11000000 00000000 00100000) (536920224) 12 1 boolean A.flag false 13 3 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 3 bytes external = 3 bytes total main locking JavaThread.synchronizestructure.A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 38 f6 c7 02 (00111000 11110110 11000111 00000010) (46659128) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) a0 c0 00 20 (10100000 11000000 00000000 00100000) (536920224) 12 1 boolean A.flag false 13 3 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 3 bytes external = 3 bytes total
00000101 依然是偏向锁，00111000 是轻量级锁
重量级锁
thread1 和 thread2 同时竞争对象a，此时输出结果为重量级锁
测试代码：
Thread.sleep(5000); A a = new A(); Thread thread1 = new Thread(){ @Override public void run() { synchronized (a){ System.out.println("thread1 locking"); System.out.println(ClassLayout.parseInstance(a).toPrintable()); try { //让线程晚点儿死亡，造成锁的竞争 Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } }; Thread thread2 = new Thread(){ @Override public void run() { synchronized (a){ System.out.println("thread2 locking"); System.out.println(ClassLayout.parseInstance(a).toPrintable()); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } } }; thread1.start(); thread2.start();
运行结果：
thread2 locking JavaThread.synchronizestructure.A object internals: OFFSET SIZE TYPE DESCRIPTION VALUE 0 4 (object header) 7a f5 99 17 (01111010 11110101 10011001 00010111) (395965818) 4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8 4 (object header) 62 c1 00 20 (01100010 11000001 00000000 00100000) (536920418) 12 1 boolean A.flag false 13 3 (loss due to the next object alignment) Instance size: 16 bytes Space losses: 0 bytes internal + 3 bytes external = 3 bytes total
01111010 basied_lock = 0 lock=10 重量级锁
