- 使用场景
- 轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。
- 轻量级锁对使用者是透明的，即语法仍然是 synchronized
- 举例，两个方法同步块对同一个对象加锁
static final Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块 A
method2();
}
}
public static void method2() {
synchronized( obj ) {
// 同步块 B
}
}
上述的流程为
- 每次指向到synchronized代码块时，都会在线程中创建一个栈帧，在栈帧中创建锁记录（Lock Record）对象，每个线程都会包括一个锁记录的结构，锁记录内部可以储存对象的Mark Word和对象引用Object reference，一开始对象头里面是01，表示没有加锁
- 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
- 如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 (轻量锁)，表示由该线程给对象加锁，这时图示如下
- 如果 cas 失败，有两种情况
- 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀阶段
- 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数，锁的可重入表示自己的线程加了2次锁，null那里表示加了几次锁。
- 当线程退出synchronized代码块（解锁的时候），如获取到取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
- 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头
- 成功，则解锁成功
- 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程
如果在尝试加轻量级锁的过程中，**CAS操作无法成功，**这是有一种情况就是其它线程已经为这个对象加上了轻量级锁（有竞争），这时候就需要膨胀成重量级锁。
static Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块
}
}
- 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁（锁标志位已经是00状态）
- 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程
- 即为对象申请Monitor锁，让Object对象指向重量级锁地址(00->01)，自己进入Monitor 的EntryList 变成BLOCKED状态
- 即为对象申请Monitor锁，让Object对象指向重量级锁地址(00->01)，自己进入Monitor 的EntryList 变成BLOCKED状态
- 当Thread-0 退出synchronized同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败，因为此时Mark Word中的锁已经从00变成了10，重量级，要进入重量级锁的解锁流程：即按照Monitor的地址找到Monitor对象，将Owner设置为null，唤醒EntryList 中的Thread-1线程，让Thread-1有机会获取到锁
- 重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时持锁退出了同步块，并释放了锁），那么当前线程就可以不用进行上下文切换就获得了锁，这时也可以避免阻塞
- 自旋重试成功的情况（线程2自旋）：线程不进入Entry List，而是一直while循环获取锁，所以这种情况适合多核CPU，单核CPU比较耗费资源，因为要一直在循环
自旋重试失败的情况（线程2自旋）：自旋了一定次数还没获取到锁，进入Entry List进行阻塞
- 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
- 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
- Java 7 之后不能控制是否开启自旋功能
- 轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。
- Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有
例如：
static final Object obj = new Object();
public static void m1(){
synchronized(obj){
// 同步块A
m2();
}
}
public static void m2(){
synchronized(obj){
// 同步块B
m3();
}
}
public static void m3(){
synchronized(obj){
//同步块C
}
}
偏向锁与轻量级所得比较
-
上篇文章中讲述了对象头的格式，对于偏向状态时的标记如下
-
一个对象创建时：
- 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的thread、epoch、age 都为 0
- 偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数 -
XX:BiasedLockingStartupDelay=0 来禁用延迟 - 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、age 都为 0，第一次用到 hashcode 时才会赋值
- 利用ClassLayout 查看对象头导入ClassLayout，如下
org.openjdk.jol
jol-core
0.16
2 . 测试代码如下
// 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0
// 参数表示表示虚拟机一启动就启动偏向锁模式，因为默认情况下，虚拟机启动4s之后才会启动偏向锁模式
public static void main(String[] args) throws IOException {
Dog d = new Dog();
ClassLayout classLayout = ClassLayout.parseInstance(d);
new Thread(() -> {
log.debug("synchronized 前");
System.out.println(classLayout.toPrintable());
synchronized (d) {
log.debug("synchronized 中");
System.out.println(classLayout.toPrintable());
}
log.debug("synchronized 后");
System.out.println(classLayout.toPrintable());
}, "t1").start();
}
class Dog{
}
- 输出如下
com.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x0000000000000005 (biasable; age: 0) 8 4 (object header: class) 0xf800ddc6 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 13:55:36.661 [t1] DEBUG test02.Pool - synchronized 中 com.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x00007fbfe111f005 (biased: 0x0000001feff8447c; epoch: 0; age: 0) 8 4 (object header: class) 0xf800ddc6 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 13:55:36.664 [t1] DEBUG test02.Pool - synchronized 后 com.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x00007fbfe111f005 (biased: 0x0000001feff8447c; epoch: 0; age: 0) 8 4 (object header: class) 0xf800ddc6 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
- 从对象头可以看出，从上述的分析可以看出
- 加锁前为0 8 (object header: mark) 0x0000000000000005 (biasable; age: 0)，这时候偏向状态为05，即最后三位为101，这时说明是默认开启了偏向锁
- 加锁中为 0 8 (object header: mark) 0x00007fbfe111f005 (biased: 0x0000001feff8447c; epoch: 0; age: 0) ，偏向状态变为线程id（操作系统分配的线程id，和java中的线程id不同。）
- 加锁后为 0 8 (object header: mark) 0x00007fbfe111f005 (biased: 0x0000001feff8447c; epoch: 0; age: 0) 处于偏向锁的对象解锁后，线程 id 仍存储于对象头中
- 禁用偏向锁后观察，运行时添加VM参数 -XX:-UseBiasedLocking 禁用偏向锁，观察输出状态
14:06:39.179 [t1] DEBUG test02.Pool - synchronized 前 com.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x0000000000000001 (non-biasable; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:06:39.185 [t1] DEBUG test02.Pool - synchronized 中 com.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x000000030dda89e0 (thin lock: 0x000000030dda89e0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:06:39.187 [t1] DEBUG test02.Pool - synchronized 后 com.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x0000000000000001 (non-biasable; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
- 禁用掉偏向锁后，优先使用轻量级锁，按轻量级锁，重量级锁的流程来
- 调用了对象的 hashCode，但偏向锁的对象 MarkWord 中存储的是线程 id，如果调用 hashCode 会导致偏向锁被撤销
- 轻量级锁会在锁记录中记录 hashCode
- 重量级锁会在 Monitor 中记录 hashCode
- 当调用对象的hashcode方法的时候就会撤销这个对象的偏向锁，因为31位的hashCode没地方存了, 所以用偏向锁是没有hashCode的，但是这里又需要hashCode，所以就会自动撤销了。
- 在调用 hashCode 后使用偏向锁，记得去掉 -XX:-UseBiasedLocking
输出为
- 当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁
- 代码演示，一个线程先加上轻量级锁，然后解锁，接着第二个线程加锁，这时候就升级了，因为第一个线程加完锁后按理来说这个对象已经是属于这个线程的了，内部保留了这个线程的信息，这时候又遇到了线程2，只能升级保证锁竞争。VM参数-XX:BiasedLockingStartupDelay=0
// 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0
// 参数表示表示虚拟机一启动就启动偏向锁模式，因为默认情况下，虚拟机启动4s之后才会启动偏向锁模式
public static void main(String[] args) throws IOException {
Dog d = new Dog();
ClassLayout classLayout = ClassLayout.parseInstance(d);
new Thread(() -> {
synchronized (d) {
log.debug("{}",classLayout.toPrintable());
}
synchronized (Test02.class) {
Test02.class.notify();
}
}, "t1").start();
Thread t2 = new Thread(() -> {
synchronized (Test02.class) {
try {
Test02.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug(classLayout.toPrintable());
synchronized (d) {
log.debug(classLayout.toPrintable());
}
log.debug(classLayout.toPrintable());
}, "t2");
t2.start();
}
输出为：
14:28:11.255 [t1] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x00007f999d87c005 (biased: 0x0000001fe66761f0; epoch: 0; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:28:11.267 [t2] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x00007f999d87c005 (biased: 0x0000001fe66761f0; epoch: 0; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:28:11.268 [t2] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x0000000306c279d0 (thin lock: 0x0000000306c279d0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:28:11.269 [t2] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x0000000000000001 (non-biasable; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
- 从上述输出可以看出，t2开始加锁的时候从偏向锁变成了轻量级锁。
- 调用wait -notify，因为这种机制只有重量级锁才有的。所以调用的时候会升级位重量级锁。
public static void main(String[] args) throws IOException {
Dog d = new Dog();
Thread t1 = new Thread(() -> {
log.debug(ClassLayout.parseInstance(d).toPrintable());
synchronized (d) {
log.debug(ClassLayout.parseInstance(d).toPrintable());
try {
d.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
log.debug(ClassLayout.parseInstance(d).toPrintable());
}
}, "t1");
t1.start();
new Thread(() -> {
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (d) {
log.debug("notify");
d.notify();
}
}, "t2").start();
}
输出为：
14:37:00.801 [t1] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x0000000000000005 (biasable; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:37:00.808 [t1] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x00007f94399dc005 (biased: 0x0000001fe50e6770; epoch: 0; age: 0) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total 14:37:05.918 [t2] DEBUG test02.Pool - notify 14:37:05.926 [t1] DEBUG test02.Pool - com.wjl.code02.Dog object internals: OFF SZ TYPE DESCRIPTION VALUE 0 8 (object header: mark) 0x00007f943b059e1a (fat lock: 0x00007f943b059e1a) 8 4 (object header: class) 0xf800ef95 12 4 (object alignment gap) Instance size: 16 bytes Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
- 从上述输出可以看出，在唤醒后，变为重量级锁
如果对象被多个线程访问，但是没有竞争，这时候偏向了线程T1的对象有机会重新偏向线程T2，重偏向会重置对象。但是由于我们之前说过如果有线程竞争是需要升级成轻量级锁的，所以要想达到重偏向，是有条件的：
- 如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象的 Thread ID
- 当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程
- 测试代码如下
public static void main(String[] args) throws IOException {
Vector list = new Vector<>();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 30; i++) {
Dog d = new Dog();
list.add(d);
synchronized (d) {
log.debug(i + "t" + ClassLayout.parseInstance(d).toPrintable());
}
}
synchronized (list) {
list.notify();
}
}, "t1");
t1.start();
Thread t2 = new Thread(() -> {
synchronized (list) {
try {
list.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("===============> ");
for (int i = 0; i < 30; i++) {
Dog d = list.get(i);
log.debug(i + "t" + ClassLayout.parseInstance(d).toPrintable());
synchronized (d) {
log.debug(i + "t" + ClassLayout.parseInstance(d).toPrintable());
}
log.debug(i + "t" + ClassLayout.parseInstance(d).toPrintable());
}
}, "t2");
t2.start();
}
批量撤销
- 当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的，这里撤销次数是指所有的线程在这个类中被撤销的次数。
- Java中的JIT即时编译器，Java是解释+编译的执行方式，JIT对Java使用解释执行，对于里面可以优化的地方会帮我们进行优化。所以下面JIT发现方法中的局部变量根本不会逃离作用范围，也就是说其他线程都没办法共享到这一数据，那么加syn锁就没有任何意义，JIT就会去掉加锁的那一行，这就是锁消除
黑马程序员多线程课程:JUC并发编程全套教程
