Java并发编程-synchronized锁优化

关于synchronized底层工作原理在上一节介绍过，本节在上节的基础上讲解synchronized优化

1.小故事

synchronized工作方式是让每个对象关联一个monitor，monitor锁是由操作系统提供的，要使用它成本较高，如果是每次进入synchronized的话需要获得一个monitor锁，那么就需要很大的开销。从Java6开始对synchronized获取锁的方式进行了优化。除了可以使用轻量级锁，还可以使用偏向级锁来进行优化。

故事角色

• 老王 - JVM

• 小南 - 线程

• 小女 - 线程

• 房间 - 对象

• 房间门上 - 防盗锁 - Monitor

• 房间门上 - 小南书包 - 轻量级锁

  扫描二维码关注公众号，回复： 12471124 查看本文章

• 房间门上 - 刻上小南大名 - 偏向锁

• 批量重刻名 - 一个类的偏向锁撤销到达 20 阈值

• 不能刻名字 - 批量撤销该类对象的偏向锁，设置该类不可偏向

小南要使用房间保证计算不被其它人干扰（原子性），最初，他用的是防盗锁，当上下文切换时，锁住门。这样，即使他离开了，别人也进不了门，他的工作就是安全的。

但是，很多情况下没人跟他来竞争房间的使用权。小女是要用房间，但使用的时间上是错开的，小南白天用，小女晚上用。每次上锁太麻烦了，有没有更简单的办法呢？

小南和小女商量了一下，约定不锁门了，而是谁用房间，谁把自己的书包挂在门口，但他们的书包样式都一样，因此每次进门前得翻翻书包，看课本是谁的，如果是自己的，那么就可以进门，这样省的上锁解锁了。万一书包不是自己的，那么就在门外等，并通知对方下次用锁门的方式。

后来，小女回老家了，很长一段时间都不会用这个房间。小南每次还是挂书包，翻书包，虽然比锁门省事了，但仍然觉得麻烦。

于是，小南干脆在门上刻上了自己的名字：【小南专属房间，其它人勿用】，下次来用房间时，只要名字还在，那么说明没人打扰，还是可以安全地使用房间。如果这期间有其它人要用这个房间，那么由使用者将小南刻的名字擦掉，升级为挂书包的方式。(偏向锁，偏向某个对象)

同学们都放假回老家了，小南就膨胀了，在 20 个房间刻上了自己的名字，想进哪个进哪个。后来他自己放假回老家了，这时小女回来了（她也要用这些房间），结果就是得一个个地擦掉小南刻的名字，升级为挂书包的方式。老王觉得这成本有点高，提出了一种批量重刻名的方法，他让小女不用挂书包了，可以直接在门上刻上自己的名字

后来，刻名的现象越来越频繁，老王受不了了：算了，这些房间都不能刻名了，只能挂书包.

2.轻量级锁

轻量级锁使用场景:如果一个对象虽然有多线程访问,但多线程访问的时间是错开的(也就是没有竞争),那么可以使用轻量级锁来优化.如果发生了竞争，那么锁会升级为重量级锁。
轻量级锁对使用者是透明的，语法依然是synchronized
假设有两个方法同步块，利用同一个对象加锁

static final Object obj = new Object();
 
public static void method1(){
    
    
    synchronized(obj){
    
    
        // 同步块A
        method2();
    }
}
 
public static void method2(){
    
    
    synchronized(obj){
    
    
        // 同步块 B
    }
}

创建锁记录(Lock record)对象,每个线程具备的栈帧都会包含一个所记录的结构，内部可以存储锁定对象的Mark Vord;

Lock Record中，Object reference记录锁对象的引用地址，lock record 地址 00记录对象的mark word。
Object中：
Mark Word对象头:hashcode 哈希码 Age:分代年龄 状态位
Klass Word: 类型指针:
Object body:类的成员变量;

Thread-0栈帧中
Lock Record中，Object reference记录锁对象的引用地址，lock record 地址 00记录对象的mark word

其中，markword结构如下：

让锁记录中Object reference指向锁对象，并尝试用cas替换Object的mark word，将mark word的值存入所记录。

将锁记录数据与对象头数据 进行交换，表示加锁;

00表示的是一种轻量级锁状态,01表示无锁状态;见上图;

如果cas替换成功,对象头中存储了锁记录地址和状态00，表示由该线程给对象加锁，如下图:

如果cas失败，有两种情况

• 如果是其他线程已经持有了该Object的轻量级锁，这时表明有竞争，进入锁膨胀过程(下一节);
• 如果是自己执行了synchronized锁重入，那么再添加一条Lock Record作为重入的计数
  也即第一次对它加了锁，第二次又对它加了锁。如上面的method1里面对obj加了锁，调用method2方法，又对obj加了锁。此时又产生了一个栈帧。这个栈帧里面又进入了synchronized，也会创建锁记录，objectreferce指向刚开要锁定的对象，然后进行cas交换的操作，不过这次交换失败了， 因为刚才已经由自己把后两位改成了00，但是它知道这是当前线程中另外一条锁记录，这种情况叫做synchronized锁冲入。也就是自己线程又一次给同一个对象加锁了。这种情况再加一个lock record,只不过数据部分存入的是锁重入的计数。
  

当退出synchronized代码块(解锁时)如果有取值为null的锁记录，表示有重入，这时重置锁记录，表示重入计数减一

当退出synchronized代码块(解锁时)锁记录的值不为null，这时使用cas将Mark Word的值恢复给对象头

成功，则解锁成功
失败，说明轻量级锁进行了锁膨胀已经升级为重量级锁，进入重量级锁解锁流程。

3.锁膨胀

如果在尝试加轻量级锁的过程中，CAS操作无法成功，这时一种情况就是有其他线程为此对象加上了轻量级锁(有竞争),这时候需要进行锁膨胀，将轻量级锁变为重量级锁。

static Object obj = new Object();
 
public static void method1(){
    
    
    synchronized(obj){
    
    
        // 同步块
    }
}

当Thread-1进行轻量级加锁时，Thread-0已经对该对象加了轻量级锁

这时Thread-1加轻量级锁失败(cas操作失败)，进入锁膨胀流程

• 即为Object对象申请Monitor锁，让Object指向重量级锁地址
• 然后自己进入Monitor的EntryList BLOCKED
  
  重量级后面两位是00
  当Thread-0退出同步块解锁时，使用cas将Mark Word的值恢复给对象头，失败。这时候会进入重量级解锁流程，即按照Monitor地址找到Monitor对象，设置Owner为null,唤醒EntryList中BLOCKED线程;

4.自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程是自旋成功(即这时候将锁线程已经退出了同步块，释放了锁)，这时当前线程就可以避免阻塞.

因为阻塞要法生产线程上下文切换，是比较耗时的。用自旋的方式就可以避免线程上下文切换的发生。
自旋适用于多核CPU的场景下，单核CPU没有意义

自旋成功的情况

线程1（CPU1上）	对象Mark	线程2（CPU2）
-	10（重量级锁）	-
访问同步块，获取Monitor	10（重量级锁）重量锁指针	-
成功（加锁）	10（重量级锁）重量锁指针	-
执行同步块	10（重量级锁）重量锁指针	-
执行同步块	10（重量级锁）重量锁指针	访问同步块，获取Monitor
执行同步块	10（重量级锁）重量锁指针	自旋重试
执行完毕	10（重量级锁）重量锁指针	自旋尝试
成功解锁	01无锁	自旋尝试
-	10（重量锁）重量锁指针	成功加锁
-	10（重量锁）重量锁指针	执行同步块

自旋失败的情况

线程1（CPU1上）	对象Mark	线程2（CPU2）
-	10（重量级锁）	-
访问同步块，获取Monitor	10（重量级锁）重量锁指针	-
成功（加锁）	10（重量级锁）重量锁指针	-
执行同步块	10（重量级锁）重量锁指针	-
执行同步块	10（重量级锁）重量锁指针	访问同步块，获取Monitor
执行同步块	10（重量级锁）重量锁指针	自旋重试
执行同步块	10（重量级锁）重量锁指针	自旋重试
执行同步块	10（重量级锁）重量锁指针	自旋重试
执行同步块	10（重量锁）重量锁指针	阻塞

• 在Java6之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次;反之，就少自旋甚至不自旋，总之，比较智能。
• 自旋会占用CPU时间，单核 CPU自旋就是浪费，多核CPU自旋才能发挥优势*
• Java7之后不能控制是否开启自旋功能

5.偏向锁

5.1.概述

轻量级锁在没有竞争时，(就自己这个线程),每次重入仍然执行CAS操作.

Java6中引入了偏向锁来做进一步优化；只有第一次使用CAS将线程ID设置到对象的Mark Word头，之后发现这个线程ID是自己的就表示没有竞争，不用重新CAS，以后只要不发生竞争，这个对象就归该线程所有

例如：

static final Object obj = new Object();
 
public static void m1(){
    
    
    synchronized(obj){
    
    
        // 同步块 A
        m2();
    }
}
 
public static void m2(){
    
    
//同一个线程再次对同一个对象加锁，此时m1还未释放锁
    synchronized(obj){
    
    
        // 同步块 B
        m3();
    }
}
 
public static void m3(){
    
    
//同一个线程再次对同一个对象加锁，此时m1，m2还未释放锁
    synchronized(obj){
    
    
        // 同步块 C
        
    }
}

优化，类似把名字刻在房间门口

即这个对象就偏向这个线程。

5.2.偏向锁状态

如图，biased_lock表示是否启用了偏向锁，如果是0，没有启用偏向锁，1就表明偏向状态。
如果是偏向状态，存储的就是线程id,epoch在后面会用到。
一个对象创建时：

如果开启了偏向锁(默认开启),那么对象创建后，markword值为0x05即最后3位101,这时它的Thread，epoch，age都为0
偏向锁默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加VM参数-xx:BiaseLockingStartupDelay=0来禁用延迟
如果没有开启偏向锁，那么对象创建后，markword值为0x01即最后3位位001，这时它的hashcode,age,都为0，第一次用到hashcode时才会赋值

偏向锁的延迟启动时间
偏向锁默认是在JVM启动4s后再初始化偏向锁，可用如下参数修改启动时间，设为0则表示立即启用。之所以这么设计是因为JVM启动的时候，如果立即启动偏向，有可能会因为线程竞争太激烈导致产生太多安全点挂起。
-XX:BiasedLockingStartupDelay=0

如果多线程环境下， 资源经常需要竞争使用，那么这个时候就不适合用偏向锁了。在测试代码运行时在添加VM参数-XX:UserBiasedLocking禁用偏向锁。

5.3.偏向锁撤销

5.3.1.调用对象hashCode

调用了对象的hashCode，但偏向锁的对象MarkWord中存储的是线程id,如果调用hashCode会导致偏向锁被撤销

• 轻量级锁会在锁记录中记录hashCode
• 重量级锁会在Monitor中记录hashCode
  在调用hashCode后使用偏向锁，记得去掉-XX:UseBiasedLocking

5.3.2.其它线程使用对象

当有其他线程使用偏向锁对象时，会将偏向锁升级为轻量级锁
注意：我们要让两个线程交错开，必须是t1线程先解锁，t2再去加锁，如果有竞争那么就是重量级锁。轻量级锁和偏向锁的前提是线程访问对象时必须是错开的。我们可以使用wait/notify来实现这样的效果。

private static void test2() throws InterruptedException {
    
    
    Dog d = new Dog();
    Thread t1 = new Thread(() -> {
    
    
        synchronized (d) {
    
    
            log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
        }
        synchronized (TestBiased.class) {
    
    
    TestBiased.class.notify();
}
// 如果不用 wait/notify 使用 join 必须打开下面的注释
// 因为：t1 线程不能结束，否则底层线程可能被 jvm 重用作为 t2 线程，底层线程 id 是一样的
/*try {
        System.in.read();
    } catch (IOException e) {
        e.printStackTrace();
    }*/
}, "t1");
    t1.start();
    Thread t2 = new Thread(() -> {
    
    
        synchronized (TestBiased.class) {
    
    
    try {
    
    
        TestBiased.class.wait();
    } catch (InterruptedException e) {
    
    
        e.printStackTrace();
    }
}
    log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    synchronized (d) {
    
    
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    }
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    }, "t2");
    t2.start();
    }

[t1] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101
[t2] - 00000000 00000000 00000000 00000000 00011111 01000001 00010000 00000101
[t2] - 00000000 00000000 00000000 00000000 00011111 10110101 11110000 01000000
[t2] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001

5.3.3.调用wait/notify

public static void main(String[] args) throws InterruptedException {
    
    
    Dog d = new Dog();
Thread t1 = new Thread(() -> {
    
    
    log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    synchronized (d) {
    
    
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    try {
    
    
        d.wait();
    } catch (InterruptedException e) {
    
    
        e.printStackTrace();
    }
        log.debug(ClassLayout.parseInstance(d).toPrintableSimple(true));
    }
}, "t1");
        t1.start();
    new Thread(() -> {
    
    
        try {
    
    
            Thread.sleep(6000);
        } catch (InterruptedException e) {
    
    
            e.printStackTrace();
        }
            synchronized (d) {
    
    
            log.debug("notify");
            d.notify();
    }
    }, "t2").start();
}

5.4.批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 T1 的对象仍有机会重新偏向 T2，重偏向会重置对象的 Thread ID
当撤销偏向锁阈值超过 20 次后，jvm 会这样觉得，我是不是偏向错了呢，于是会在给这些对象加锁时重新偏向至加锁线程

private static void test3() throws InterruptedException {
    
    
	Vector<Dog> 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).toPrintableSimple(true));
			}
		}
		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).toPrintableSimple(true));
			synchronized (d) {
    
    
				log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
			log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
	}, "t2");
	t2.start();
}

[t1] - 0 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 1 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 2 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 3 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 4 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 5 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 6 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 7 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 8 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 9 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 10 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 11 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 12 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 13 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 14 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 15 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 16 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 17 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 18 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t1] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - ===============>
[t2] - 0 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 0 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 0 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 1 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 1 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 1 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 2 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 2 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 2 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 3 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 3 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 3 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 4 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 4 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 4 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 5 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 5 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 5 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 6 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 6 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 6 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 7 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 7 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 7 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 8 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 8 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 8 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 9 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 9 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 9 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 10 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 10 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 10 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 11 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 11 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 11 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 12 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 12 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 12 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 13 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 13 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 13 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 14 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 14 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 14 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 15 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 15 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 15 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 16 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 16 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 16 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 17 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 17 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 17 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 18 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 18 00000000 00000000 00000000 00000000 00100000 01011000 11110111 00000000
[t2] - 18 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 19 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 20 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 21 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 22 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 23 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 24 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 25 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 26 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 27 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 28 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11100000 00000101
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101
[t2] - 29 00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101

5.5.批量撤销

当撤销偏向锁阈值超过 40 次后，jvm 会这样觉得，自己确实偏向错了，根本就不该偏向。于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。

static Thread t1,t2,t3;
private static void test4() throws InterruptedException {
    
    
	Vector<Dog> list = new Vector<>();
	int loopNumber = 39;
	t1 = new Thread(() -> {
    
    
		for (int i = 0; i < loopNumber; i++) {
    
    
			Dog d = new Dog();
			list.add(d);
			synchronized (d) {
    
    
				log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
		}
		LockSupport.unpark(t2);
	}, "t1");
	t1.start();
	t2 = new Thread(() -> {
    
    
		LockSupport.park();
		log.debug("===============> ");
		for (int i = 0; i < loopNumber; i++) {
    
    
			Dog d = list.get(i);
			log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
			synchronized (d) {
    
    
				log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
			log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
		LockSupport.unpark(t3);
	}, "t2");
	t2.start();
	t3 = new Thread(() -> {
    
    
		LockSupport.park();
		log.debug("===============> ");
		for (int i = 0; i < loopNumber; i++) {
    
    
			Dog d = list.get(i);
			log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
			synchronized (d) {
    
    
				log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
			}
			log.debug(i + "\t" + ClassLayout.parseInstance(d).toPrintableSimple(true));
		}
	}, "t3");
	t3.start();
	t3.join();
	log.debug(ClassLayout.parseInstance(new Dog()).toPrintableSimple(true));
}

6.其它优化

6.1. 减少上锁时间

同步代码块中尽量短.。
上锁时间短，竞争机会少，如果是交错运行下，此时可以用轻量级锁来优化。如果上锁时间长，交错机会就增加了，轻量级锁就会升级为重量级锁。所以尽量让synchronized代码块尽可能短。

6.2.减少锁的粒度

将一个锁拆分为多个锁提高并发度

• ConcurrentHashMap(在数组的链表头上进行加锁，如果hashtable就锁住了整个的hashtable,如果我只锁住了链表头，加锁的粒度就变小了，每次只锁住了一个链表，其它链表读写操作不会受到任何影响)
• LongAdder分为base和cells两部分，没有并发争用的时候或者是cells数组正在初始化时候，会使用CAS来累加值到base,有并发争用，会初始化 cells 数组，数组有多少个 cell，就允 许有多少线程并行修改，后将数组中每个 cell 累加，再加上 base 就是终的值
• LinkedBlockingQueue 入队和出队使用不同的锁，相对于LinkedBlockingArray只有一个锁效率要高

6.3.锁粗化

多次循环进入同步块不如同步块内多次循环 另外 JVM 可能会做如下优化，把多次 append 的加锁操作 粗化为一次（因为都是对同一个对象加锁，没必要重入多次）

new StringBuffer().append("a").append("b").append("c");

6.4.锁消除

JVM 会进行代码的逃逸分析，例如某个加锁对象是方法内局部变量，不会被其它线程所访问到，这时候 就会被即时编译器忽略掉所有同步操作

6.5. 读写分离

CopyOnWriteArrayList ConyOnWriteSet