Java并发编程-synchronized锁优化
目录
- 1.小故事
- 2.轻量级锁
- 3.锁膨胀
- 4.自旋优化
- 5.偏向锁
- 5.1.概述
- 5.2.偏向锁状态
- 5.3.偏向锁撤销
- 5.3.1.调用对象hashCode
- 5.3.2.其它线程使用对象
- 5.3.3.调用wait/notify
- 5.4.批量重偏向
- 5.5.批量撤销
- 6.其它优化
- 6.1. 减少上锁时间
- 6.2.减少锁的粒度
- 6.3.锁粗化
- 6.4.锁消除
- 6.5. 读写分离
关于synchronized底层工作原理在上一节介绍过，本节在上节的基础上讲解synchronized优化
1.小故事
synchronized工作方式是让每个对象关联一个monitor，monitor锁是由操作系统提供的，要使用它成本较高，如果是每次进入synchronized的话需要获得一个monitor锁，那么就需要很大的开销。从Java6开始对synchronized获取锁的方式进行了优化。除了可以使用轻量级锁，还可以使用偏向级锁来进行优化。
故事角色
老王 - JVM
小南 - 线程
小女 - 线程
房间 - 对象
房间门上 - 防盗锁 - Monitor
房间门上 - 小南书包 - 轻量级锁
房间门上 - 刻上小南大名 - 偏向锁
批量重刻名 - 一个类的偏向锁撤销到达 20 阈值
不能刻名字 - 批量撤销该类对象的偏向锁，设置该类不可偏向
小南要使用房间保证计算不被其它人干扰（原子性），最初，他用的是防盗锁，当上下文切换时，锁住门。这样，即使他离开了，别人也进不了门，他的工作就是安全的。
但是，很多情况下没人跟他来竞争房间的使用权。小女是要用房间，但使用的时间上是错开的，小南白天用，小女晚上用。每次上锁太麻烦了，有没有更简单的办法呢？
小南和小女商量了一下，约定不锁门了，而是谁用房间，谁把自己的书包挂在门口，但他们的书包样式都一样，因此每次进门前得翻翻书包，看课本是谁的，如果是自己的，那么就可以进门，这样省的上锁解锁了。万一书包不是自己的，那么就在门外等，并通知对方下次用锁门的方式。
后来，小女回老家了，很长一段时间都不会用这个房间。小南每次还是挂书包，翻书包，虽然比锁门省事了，但仍然觉得麻烦。
于是，小南干脆在门上刻上了自己的名字：【小南专属房间，其它人勿用】，下次来用房间时，只要名字还在，那么说明没人打扰，还是可以安全地使用房间。如果这期间有其它人要用这个房间，那么由使用者将小南刻的名字擦掉，升级为挂书包的方式。(偏向锁，偏向某个对象)
同学们都放假回老家了，小南就膨胀了，在 20 个房间刻上了自己的名字，想进哪个进哪个。后来他自己放假回老家了，这时小女回来了（她也要用这些房间），结果就是得一个个地擦掉小南刻的名字，升级为挂书包的方式。老王觉得这成本有点高，提出了一种批量重刻名的方法，他让小女不用挂书包了，可以直接在门上刻上自己的名字
后来，刻名的现象越来越频繁，老王受不了了：算了，这些房间都不能刻名了，只能挂书包.
2.轻量级锁
轻量级锁使用场景:如果一个对象虽然有多线程访问,但多线程访问的时间是错开的(也就是没有竞争),那么可以使用轻量级锁来优化.如果发生了竞争，那么锁会升级为重量级锁。
轻量级锁对使用者是透明的，语法依然是synchronized
假设有两个方法同步块，利用同一个对象加锁
static final Object obj = new Object();public static void method1(){synchronized(obj){// 同步块Amethod2();}
}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){// 同步块 Am2();}
}public static void m2(){//同一个线程再次对同一个对象加锁，此时m1还未释放锁synchronized(obj){// 同步块 Bm3();}
}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
Java并发编程-synchronized锁优化相关推荐
- Java并发编程—Synchronized底层优化（偏向锁、轻量级锁）
原文作者:Matrix海 子 原文地址:Java并发编程:Synchronized底层优化(偏向锁.轻量级锁) 目录 一.重量级锁 二.轻量级锁 三.偏向锁 四.其他优化 五.总结 一.重量级锁 上篇 ...
- Java并发编程-无锁CAS与Unsafe类及其并发包Atomic
[版权申明]未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) http://blog.csdn.net/javazejian/article/details/72772470 出自[zejian ...
- Java并发编程之锁机制之LockSupport工具
关于文章涉及到的jdk源码,这里把最新的jdk源码分享给大家----->jdk源码 前言 在上篇文章<Java并发编程之锁机制之AQS(AbstractQueuedSynchronizer ...
- Java并发编程 synchronized保证线程安全的原理
文章转载致博客 blog.csdn.net/javazejian/- 自己稍加完善. 线程安全是并发编程中的重要关注点,应该注意到的是,造成线程安全问题的主要诱因有两点,一是存在共享数据(也称临界资源 ...
- Java 并发编程—Synchronized关键字
原文作者:liuxiaopeng 原文地址:Java并发编程:Synchronized及其实现原理 目录 一.Synchronized的基本使用 二.Synchronized 原理 三.运行结果解释 ...
- Java 并发编程—有锁互斥机制及AQS理论
原文作者:Java并发编程 原文地址:AQS这样学就很简单了 目录 一.有锁互斥机制 二.AQS如何实现互斥 三.结语 如果你是道格李,你要实现一套机制来保证线程互斥,你会如何实现呢?你肯定不会一上来 ...
- java并发锁有哪些,Java并发编程-公平锁与非公平锁
写这个文章的时候让我想起了让子弹飞的一个台词 公平,公平,还是tmd公平! 什么是公平和非公平 首先,我们来看下什么是公平锁和非公平锁. 公平锁指的是按照线程请求的顺序,来分配锁: 非公平锁指的是不完 ...
- 【java】java 并发编程 StampedLock 锁 【不重要】
文章目录 1.概述 2.synchronized 3.读写锁 3.1 读写锁缺点 4.StampedLock 4.1 缺点 5.案例 5.1 案例1 5.1 案例2 6.性能对比 7.总结 1.概述 ...
- Java 多线程编程（锁优化）
来自:老九学堂 并发环境下进行编程时,需要使用锁机制来同步多线程间的操作,保证共享资源的互斥访问. 加锁会带来性能上的损坏,似乎是众所周知的事情. 然而,加锁本身不会带来多少的性能消耗,性能主要是在线 ...
最新文章
- 常用插值算法介绍(二)
- 工厂方法（父类定义创建对象的接口，通过多态让子类来创建具体的对象）
- 视觉SLAM找工作面试问题集锦（转自网络）
- 增大mysql修改表空间_Oracle修改表空间为自动扩展
- 小米百万美金大奖花落机器狗团队，5 年千亿重砸研发鼓励创新
- 【bzoj2330】 [SCOI2011]糖果
- Android Studio 第一个JNI程序
- python美女源代码_python程序员爬取百套美女写真集，同样是爬虫，他为何如此突出...
- 重庆市谷歌卫星地图下载
- 主成分与因子分析异同_浅谈主成分分析与因子分析
- 计算机学院研发------考核之界面
- vba字典重复key_VBA字典技术整理
- 海外观看2022卡塔尔世界杯中文直播攻略大全
- 什么是TailwindCSS
- 分享一些图片懒加载组件的设计思路
- java源码解读 pdf_好家伙！这一篇文章就给你讲明白了Java并发实现原理之JDK源码剖析(PDF文档)...
- openlayers学习——3、openlayers加点加圆加图标图片
- 考研政治——马克思三大定律之否定之否定
- JS监听页面元素删除子节点、增加子节点、修改子节点的内容
- jQuery---仿芒果网机票预定智能输入提示