Java并发编程-synchronized锁优化

并发编程 同时被 3 个专栏收录
18 篇文章 1 订阅
198 篇文章 2 订阅
19 篇文章 1 订阅

关于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){
        // 同步块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(重量级锁)-
访问同步块,获取Monitor10(重量级锁)重量锁指针-
成功(加锁)10(重量级锁)重量锁指针-
执行同步块10(重量级锁)重量锁指针-
执行同步块10(重量级锁)重量锁指针访问同步块,获取Monitor
执行同步块10(重量级锁)重量锁指针自旋重试
执行完毕10(重量级锁)重量锁指针自旋尝试
成功解锁01无锁自旋尝试
-10(重量锁)重量锁指针成功加锁
-10(重量锁)重量锁指针执行同步块

自旋失败的情况

线程1(CPU1上)对象Mark线程2(CPU2)
-10(重量级锁)-
访问同步块,获取Monitor10(重量级锁)重量锁指针-
成功(加锁)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

  • 5
    点赞
  • 5
    评论
  • 5
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值