JDK1.6之后synchronized关键字底层优化

JDK1.6 对锁的实现引入了大量的优化，如偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术来减少锁操作的开销。

锁主要存在四种状态，依次是：无锁状态、偏向锁状态、轻量级锁状态、重量级锁状态，他们会随着竞争的激烈而逐渐升级。注意锁可以升级不可降级，这种策略是为了提高获得锁和释放锁的效率。

何为重量级锁

synchronized在jdk1.6之前，一直都是重量级锁。为什么称之为重量级锁呢，主要是因为锁的资源是通过操作系统去申请 ，所以比较重量级。synchronized底层是借助操作系统的Mutex Lock(互斥锁)来实现的线程同步。

synchronized实现方式

JVM基于进入和退出Monitor对象来实现方法同步和代码块同步, 但是两者的实现细节不一样。

1. 代码块同步: 通过使用monitorenter和monitorexit指令实现的.

2. 同步方法: ACC_SYNCHRONIZED修饰

monitorenter指令是在编译后插入到同步代码块的开始位置, 而monitorexit指令是在编译后插入到同步代码块的结束处或异常处。

示例代码

为了证明JVM的实现方式, 下面通过反编译代码来证明。

public class Demo {
    public void f1() {        synchronized (Demo.class) {            System.out.println("Hello World.");        }    }
    public synchronized void f2() {        System.out.println("Hello World.");    }
}

编译之后的字节码如下(只摘取了方法的字节码):​​​​​​​

public void f1();  descriptor: ()V  flags: ACC_PUBLIC  Code:    stack=2, locals=3, args_size=1       0: ldc           #2                         2: dup       3: astore_1       4: monitorenter       5: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;       8: ldc           #4                  // String Hello World.      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V      13: aload_1      14: monitorexit      15: goto          23      18: astore_2      19: aload_1      20: monitorexit      21: aload_2      22: athrow      23: return    Exception table:       from    to  target type           5    15    18   any          18    21    18   any    LineNumberTable:      line 6: 0      line 7: 5      line 8: 13      line 9: 23    StackMapTable: number_of_entries = 2      frame_type = 255 /* full_frame */        offset_delta = 18        locals = [ class me/snail/base/Demo, class java/lang/Object ]        stack = [ class java/lang/Throwable ]      frame_type = 250 /* chop */        offset_delta = 4
public synchronized void f2();  descriptor: ()V  flags: ACC_PUBLIC, ACC_SYNCHRONIZED  Code:    stack=2, locals=1, args_size=1       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;       3: ldc           #4                  // String Hello World.       5: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V       8: return    LineNumberTable:      line 12: 0      line 13: 8}

先说f1()方法, 发现其中一个monitorenter对应了两个monitorexit, 这是不是错的？但是仔细看#15: goto语句, 直接跳转到了#23: return处, 再看#22: athrow语句发现, 原来第二个monitorexit是保证同步代码块抛出异常时锁能得到正确的释放而存在的, 这就理解了.

综上: 发现同步代码块是通过monitorenter和monitorexit来实现的; 同步方法是加了一个ACC_SYNCHRONIZED修饰来实现的。

Java对象头(存储锁类型)

在HotSpot虚拟机中, 对象在内存中的布局分为三块区域: 对象头, 示例数据和对其填充。

对象头中包含两部分: MarkWord 和 类型指针。

如果是数组对象的话, 对象头还有一部分是存储数组的长度。

多线程下synchronized的加锁就是对同一个对象的对象头中的MarkWord中的变量进行CAS操作。

MarkWord

Mark Word用于存储对象自身的运行时数据, 如HashCode, GC分代年龄, 锁状态标志, 线程持有的锁, 偏向线程ID等等.
占用内存大小与虚拟机位长一致(32位JVM -> MarkWord是32位, 64位JVM->MarkWord是64位).

类型指针

类型指针指向对象的类元数据, 虚拟机通过这个指针确定该对象是哪个类的实例.

对象头的长度

对象头的长度

如果是数组对象的话, 虚拟机用3个字宽(32/64bit + 32/64bit + 32/64bit)存储对象头; 如果是普通对象的话, 虚拟机用2字宽存储对象头(32/64bit + 32/64bit).

锁的升级

偏向锁

偏向锁是针对于一个线程而言的, 线程获得锁之后就不会再有解锁等操作了, 这样可以省略很多开销. 假如有两个线程来竞争该锁话, 那么偏向锁就失效了, 进而升级成轻量级锁了.

为什么要这样做呢? 因为经验表明, 其实大部分情况下, 都会是同一个线程进入同一块同步代码块的. 这也是为什么会有偏向锁出现的原因.

在Jdk1.6中, 偏向锁的开关是默认开启的, 适用于只有一个线程访问同步块的场景。

偏向锁的加锁

当一个线程访问同步块并获取锁时, 会在锁对象的对象头和栈帧中的锁记录里存储锁偏向的线程ID, 以后该线程进入和退出同步块时不需要进行CAS操作来加锁和解锁, 只需要简单的测试一下锁对象的对象头的MarkWord里是否存储着指向当前线程的偏向锁(线程ID是当前线程), 如果测试成功, 表示线程已经获得了锁; 如果测试失败, 则需要再测试一下MarkWord中偏向锁的标识是否设置成1(表示当前是偏向锁), 如果没有设置, 则使用CAS竞争锁, 如果设置了, 则尝试使用CAS将锁对象的对象头的偏向锁指向当前线程.

偏向锁的撤销

偏向锁使用了一种等到竞争出现才释放锁的机制, 所以当其他线程尝试竞争偏向锁时, 持有偏向锁的线程才会释放锁. 偏向锁的撤销需要等到全局安全点(在这个时间点上没有正在执行的字节码). 首先会暂停持有偏向锁的线程, 然后检查持有偏向锁的线程是否存活, 如果线程不处于活动状态, 则将锁对象的对象头设置为无锁状态; 如果线程仍然活着, 则锁对象的对象头中的MarkWord和栈中的锁记录要么重新偏向于其它线程要么恢复到无锁状态, 最后唤醒暂停的线程(释放偏向锁的线程).

偏向锁在Java6及更高版本中是默认启用的, 但是它在程序启动几秒钟后才激活. 可以使用-XX:BiasedLockingStartupDelay=0来关闭偏向锁的启动延迟, 也可以使用-XX:-UseBiasedLocking=false来关闭偏向锁, 那么程序会直接进入轻量级锁状态.

轻量级锁

当出现有两个线程来竞争锁的话, 那么偏向锁就失效了, 此时锁就会膨胀, 升级为轻量级锁.

轻量级锁加锁

线程在执行同步块之前, JVM会先在当前线程的栈帧中创建用户存储锁记录的空间, 并将对象头中的MarkWord复制到锁记录中. 然后线程尝试使用CAS将对象头中的MarkWord替换为指向锁记录的指针. 如果成功, 当前线程获得锁; 如果失败, 表示其它线程竞争锁, 当前线程便尝试使用自旋来获取锁, 之后再来的线程, 发现是轻量级锁, 就开始进行自旋.

轻量级锁解锁

轻量级锁解锁时, 会使用原子的CAS操作将当前线程的锁记录替换回到对象头, 如果成功, 表示没有竞争发生; 如果失败, 表示当前锁存在竞争, 锁就会膨胀成重量级锁.

总结

总结一下加锁解锁过程, 有线程A和线程B来竞争对象C的锁(如: synchronized(C){} ), 这时线程A和线程B同时将对象C的MarkWord复制到自己的锁记录中, 两者竞争去获取锁, 假设线程A成功获取锁, 并将对象C的对象头中的线程ID(MarkWord中)修改为指向自己的锁记录的指针, 这时线程B仍旧通过CAS去获取对象C的锁, 因为对象C的MarkWord中的内容已经被线程A改了, 所以获取失败. 此时为了提高获取锁的效率, 线程B会循环去获取锁, 这个循环是有次数限制的, 如果在循环结束之前CAS操作成功, 那么线程B就获取到锁；如果循环结束依然获取不到锁, 则获取锁失败, 对象C的MarkWord中的记录会被修改为重量级锁, 然后线程B就会被挂起, 之后有线程D来获取锁时, 看到对象C的MarkWord中的是重量级锁的指针, 说明竞争激烈, 直接挂起.

解锁时, 线程A尝试使用CAS将对象C的MarkWord改回自己栈中复制的那个MarkWord, 因为对象C中的MarkWord已经被指向为重量级锁了, 所以CAS失败. 线程A会释放锁并唤起等待的线程, 进行新一轮的竞争.

各种锁之间的对比

各种锁之间的对比

锁升级过程

锁升级过程

锁升级过程中markword的变化

升级过程中markword的变化

转载：JDK1.6之后synchronized关键字底层优化 (qq.com)