当前位置：网站首页>并发之Synchronized说明

并发之Synchronized说明

2022-06-26 16:50:00 【七国的天下，我要九十九】

并发之Synchronized说明

1 Monitor概述

Java对象头

以32位虚拟机为例:

普通对象

在这里插入图片描述

数组对象

在这里插入图片描述

其中Mark Word结构

在这里插入图片描述

一般组成为:

25位 hashcode + 分代年龄(经过几次回收仍存在再移至老年代) + 是否启用偏向锁(0否 1是)+加锁标识信息

锁标识:
01 没锁
00 轻量级锁
10 重量级锁

2 Monitor锁

Monitor, 又称监视器或管程.每个Java对象都可以关联一个Monitor对象,如果Synchronized给对象上锁(重量级)之后, 该对象头的Mark Word中设置就指向Monitor对象的指针

在这里插入图片描述

说明:

刚开始Monitor中的Owner为null
当线程2执行synchronized(obj)就会将Monitor的所有者Owner置为线程2, Monitor中只能有一个Owner
线程2上锁的过程中, 如果线程3,线程4,线程5也来执行synchronized(obj),就会进入EntryList Blocked
线程2执行完同步代码块内容,会唤醒EntryList中等待的线程来竞争锁, 竞争的是非公平的(内置了策略,不是随机的)

synchronized必须是进入同一对象的monitor才有效果
不加synchronized对象不会管理监视器,不遵从该规则

3 Synchronized进阶

1 轻量级锁

使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是 synchronized

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

说明:

1 创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的 Mark Word

在这里插入图片描述

2 让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录

在这里插入图片描述

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

在这里插入图片描述

4 如果 cas 失败，有两种情况
- 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
- 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数

在这里插入图片描述

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ekWWkzV4-1656224885218)(assets/image-20220626092449488.png)]

6 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头
- 成功，则解锁成功
- 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

2 锁膨胀

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

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

1 当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
2 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程
- 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
- 然后自己进入 Monitor 的 EntryList BLOCKED

在这里插入图片描述

3 当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程.

3 自旋优化

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

成功情况

在这里插入图片描述

失败情况

在这里插入图片描述

说明:

自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势
在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能
Java 7 之后不能控制是否开启自旋功能, 即底层自己实现

4 偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 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
 }
}

在这里插入图片描述

偏向状态

64位对象头格式

在这里插入图片描述

一个对象创建时:

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

1 测试延迟性

class Dog {
    }

利用第三方工具jol查看请求头信息

// 添加虚拟机参数 -XX:BiasedLockingStartupDelay=0 
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.toPrintableSimple(true));
 synchronized (d) {
    
 log.debug("synchronized 中");
 System.out.println(classLayout.toPrintableSimple(true));
 }
 log.debug("synchronized 后");
 System.out.println(classLayout.toPrintableSimple(true));
 }, "t1").start();
}
/* 运行结果: 11:08:58.117 c.TestBiased [t1] - synchronized 前 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 11:08:58.121 c.TestBiased [t1] - synchronized 中 00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 11:08:58.121 c.TestBiased [t1] - synchronized 后 00000000 00000000 00000000 00000000 00011111 11101011 11010000 00000101 */

处于偏向锁的对象解锁后，线程 id 仍存储于对象头中

测试禁用

在上面测试代码运行时在添加 VM 参数 -XX:-UseBiasedLocking 禁用偏向锁

/* 运行结果: 11:13:10.018 c.TestBiased [t1] - synchronized 前 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 11:13:10.021 c.TestBiased [t1] - synchronized 中 00000000 00000000 00000000 00000000 00100000 00010100 11110011 10001000 11:13:10.021 c.TestBiased [t1] - synchronized 后 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001 */

测试hashCode

正常状态对象一开始是没有 hashCode 的，第一次调用才生成

2 撤销

1 调用对象hashCode

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

轻量级锁会在锁记录中记录 hashCode
重量级锁会在 Monitor 中记录 hashCode

在调用 hashCode 后使用偏向锁，记得去掉 -XX:-UseBiasedLocking

/* 11:22:10.386 c.TestBiased [main] - 调用 hashCode:1778535015 11:22:10.391 c.TestBiased [t1] - synchronized 前 00000000 00000000 00000000 01101010 00000010 01001010 01100111 00000001 11:22:10.393 c.TestBiased [t1] - synchronized 中 00000000 00000000 00000000 00000000 00100000 11000011 11110011 01101000 11:22:10.393 c.TestBiased [t1] - synchronized 后 00000000 00000000 00000000 01101010 00000010 01001010 01100111 00000001 */

2 其它线程使用对象

当有其它线程使用偏向锁对象时，会将偏向锁升级为轻量级锁

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 */

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();
}
/* [t1] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101 [t1] - 00000000 00000000 00000000 00000000 00011111 10110011 11111000 00000101 [t2] - notify [t1] - 00000000 00000000 00000000 00000000 00011100 11010100 00001101 11001010 */

3 批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 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();
}

4 批量撤销

当撤销偏向锁阈值超过 20 次后，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));
}

5 锁消除

案例

@Fork(1)
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations=3)
@Measurement(iterations=5)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public class MyBenchmark {
    
 static int x = 0;
 @Benchmark
 public void a() throws Exception {
    
 x++;
 }
 @Benchmark
 public void b() throws Exception {
    
 Object o = new Object();
 synchronized (o) {
    
 x++;
      }
 }
}

使用命令执行jar包: java -jar benchmarks.jar

Benchmark Mode Samples Score Score error Units 
c.i.MyBenchmark.a avgt 5 1.542 0.056 ns/op 
c.i.MyBenchmark.b avgt 5 1.518 0.091 ns/op

两个方法执行时间相差不大, 因为b方法内虽然添加锁, 但是每个锁对象不一致,故系统判断锁无效,即实际没有加锁效果.

禁用锁消除

执行命令: java -XX:-EliminateLocks -jar benchmarks.jar

Benchmark Mode Samples Score Score error Units 
c.i.MyBenchmark.a avgt 5 1.507 0.108 ns/op 
c.i.MyBenchmark.b avgt 5 16.976 1.572 ns/op

b方法使用时间明显较长.

锁粗化

对相同对象多次加锁，导致线程发生多次重入，可以使用锁粗化方式来优化，这不同于之前讲的细分锁的粒度。

原网站

版权声明
本文为[七国的天下，我要九十九]所创，转载请带上原文链接，感谢
https://blog.csdn.net/ABestRookie/article/details/125469703

当前位置：网站首页>并发之Synchronized说明

并发之Synchronized说明