Java并发(二十)----synchronized原理进阶

news2024/9/30 1:42:07

1、小故事

故事角色

  • 老王 - JVM

  • 小南 - 线程

  • 小女 - 线程

  • 房间 - 对象

  • 房间门上 - 防盗锁 - Monitor-重量级锁

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

  • 房间门上 - 刻上小南大名 - 偏向锁 -对象专属于某个线程使用

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

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

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

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

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

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

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

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

后来，刻名的现象越来越频繁，老王受不了了：算了，这些房间都不能刻名了，只能挂书包----设置该类不可偏向

节码指令中有所体现

2、synchronized 原理进阶

2.1 轻量级锁

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

如果有竞争，轻量级锁会升级为重量级锁。

轻量级锁对使用者是透明的，即语法仍然是 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 Word

  • 让锁记录中 Object reference 指向锁对象，并尝试用 cas（compare and swap，原子性） 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录

  • 如果 cas（compare and swap，原子性） 替换成功，对象头中存储了锁记录地址和状态 00，表示由该线程给对象加锁，这时图示如下

  • 如果 cas（compare and swap，原子性） 失败，有两种情况

    • 如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程

    • 如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数，如示例代码

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

  • 当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas（compare and swap，原子性） 将 Mark Word 的值恢复给对象头

    • 成功，则解锁成功

    • 失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程

2.2 锁膨胀

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

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

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

  • 这时 Thread-1 加轻量级锁失败，进入锁膨胀流程

    • 即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址

    • 然后自己进入 Monitor 的 EntryList BLOCKED

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

2.3 自旋优化

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

自旋重试成功的情况

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

线程2自旋重试3次成功加锁，这样就不会陷入阻塞。

自旋重试失败的情况

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

  • 线程2一直处于自旋，最后处于阻塞状态。

  • 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。

  • 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。

  • Java 7 之后不能控制是否开启自旋功能

2.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
    }
}

2.4.1 偏向状态

回忆一下对象头格式

|--------------------------------------------------------------------|--------------------|
|                        Mark Word (64 bits)                         |       State        |
|--------------------------------------------------------------------|--------------------|
| unused:25 | hashcode:31 | unused:1 | age:4 | biased_lock:0 | 01    |       Normal       |  // 正常
|--------------------------------------------------------------------|--------------------|  // 偏向锁
| thread:54 | epoch:2     | unused:1 | age:4 | biased_lock:1 | 01    |       Biased       |
|--------------------------------------------------------------------|--------------------|
|             ptr_to_lock_record:62                          | 00    | Lightweight Locked |  // 轻量级
|--------------------------------------------------------------------|--------------------|  // 重量级
|             ptr_to_heavyweight_monitor:62                  | 10    | Heavyweight Locked |
|--------------------------------------------------------------------|--------------------|
|                                                            | 11    |    Marked for GC   |
|--------------------------------------------------------------------|--------------------|

一个对象创建时：

  • 如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的 thread、epoch、age 都为 0

  • 偏向锁是默认是延迟的，不会在程序启动时立即生效，可以sleep 4s后查看，如果想避免延迟，可以加 VM 参数 -XX:BiasedLockingStartupDelay=0 来禁用延迟

  • 如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、age 都为 0，第一次用到 hashcode 时才会赋值

1） 测试延迟特性
2） 测试偏向锁
class Dog {}

利用 jol 第三方工具来查看对象头信息

pom文件

        <dependency>
            <groupId>org.openjdk.jol</groupId>
            <artifactId>jol-core</artifactId>
            <version>0.10</version>
        </dependency>

代码（注意这一小节的代码了解一下即可，在本机是运行不成功的，注意看输出就行了）

// 添加虚拟机参数 -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        //VM 参数 `-XX:BiasedLockingStartupDelay=0`后
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不变，除非有新的竞争

注意

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

3）测试禁用

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

输出

11:13:10.018 c.TestBiased [t1] - synchronized 前
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001     // 三条日志后三位均不是101
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     // 恢复成正常状态

4) 测试 hashCode，添加VM 参数 -XX:BiasedLockingStartupDelay=0 来禁用延迟

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

  • 调用 hashCode 会导致偏向锁被禁用。因为处于偏向锁状态的话已经存储线程id，再去存储hashcode，空间不够，是存储不下的。所以这时候的状态会被改为正常状态。另外轻量级锁的hashcode存储在栈帧中的锁记录中，重量级锁的hashcode存储在monitor对象中，解锁时会还原。

2.4.2 撤销 - 调用对象 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.4.3 撤销 - 其它线程使用对象

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

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(); // 等待t1线程
            } 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线程还未加锁和t1状态保持一致
[t2] - 00000000 00000000 00000000 00000000 00011111 10110101 11110000 01000000  //  处于轻量级锁
[t2] - 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001  //  解锁后处于不可偏向
2.4.4 撤销 - 调用 wait/notify

这种情况下也会撤销偏向锁。因为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  // 重量级锁
2.4.5 批量重偏向

如果对象虽然被多个线程访问，但没有竞争，这时偏向了线程 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 // 偏向t1锁
[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  // 第20个对象开始,全部处于偏向t2的偏向锁
[t2] - 19   00000000 00000000 00000000 00000000 00011111 11110011 11110001 00000101  // 批量重偏向,后面所有都处于偏向t2的偏向锁
[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
2.4.6 批量撤销

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

参考资料

https://github.com/farmerjohngit/myblog/issues/12

https://www.cnblogs.com/LemonFive/p/11246086.html

https://www.cnblogs.com/LemonFive/p/11248248.html

偏向锁论文

2.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++;
        }
    }
}

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是有一个加锁的操作，那为什么a耗时与b耗时几乎别区别呢？是因为Java中有一个JIT（即时编译器），会对于反复执行的代码进行优化，b中o对象根本不会被共享，所以b中的synchronized是没有任何意义的，所以Java就把锁给消除了。这也是存在一个开关的，这个开关是默认开启的，下面演示下把这个开关关闭掉。

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

可以看到耗时有明显差距了。

锁粗化

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

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1322896.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

从企业的角度看待WMS仓储管理系统的集成

从企业的角度看待WMS仓储管理系统的集成

随着全球化和数字化的发展&#xff0c;企业面临着越来越复杂的商业环境。为了满足高效运营的需求&#xff0c;许多企业开始寻求更先进、更集成的解决方案来优化他们的仓储流程。WMS仓储管理系统作为一种重要的解决方案&#xff0c;在企业中发挥着关键的作用。本文将从企业的角度…
阅读更多...
Android studio Android SDK下载安装

Android studio Android SDK下载安装

我们访问地址 https://developer.android.google.cn/studio?hlzh-cn 拉下来直接点击下载 然后来下来 勾选 然后点击下载 下载好之后 我们双击打开 点击下一步 确认上面的勾选 然后下一步 这里 我们选择一下安装目录 然后点击下一步 安装 安装完之后点击进行下一步 Fin…
阅读更多...
echarts 饼图3样式

echarts 饼图3样式

父组件&#xff1a; <pieChartNormal :opt"contractStatics" style"width: 100%;height: 100%;" />import pieChartNormal from "./components/pieChartNormal";data() {return {contractStatics: {seriesData: [{name: 技术服务类,value:…
阅读更多...
Gemini Pro API 详细申请步骤

Gemini Pro API 详细申请步骤

Gemini Pro API 详细申请步骤 什么是 Gemini ? 上周&#xff0c;谷歌发布了 Gemini&#xff08;双子座&#xff09;&#xff0c;它是谷歌最新、最强大的人工智能模型&#xff0c;旨在迎头痛击 OpenAI 的 GPT。Gemini 在构建时考虑到了多模态性&#xff0c;这意味着它能够理解…
阅读更多...
SG3524控制的恒流源电路图

SG3524控制的恒流源电路图

SG3524简介 SG3524是开关电源脉宽调制型控制器。应用于开关稳压器&#xff0c;变压器耦合的直流变换器&#xff0c;电压倍增器&#xff0c;极性转换器等。采用固定频率&#xff0c;脉冲宽度调制&#xff08;脉宽调制&#xff09;技术。输出允许单端或推挽输出。芯片电路包括电…
阅读更多...
卸载MySQL——Windows

卸载MySQL——Windows

1. 停止MySQL服务 winR 打开运行&#xff0c;输入 services.msc 点击 “确定” 调出系统服务。 我这里只有一个&#xff0c;只要是以MySQL开头的全部停止 2. 卸载MySQL相关组件 打开控制面板 —> 卸载程序 —> 卸载MySQL相关所有组件 3. 删除MySQL安装目录 一般是C:\P…
阅读更多...
Oracle的学习心得和知识总结（三十）| OLTP 应用程序的合成工作负载生成器Lauca论文翻译及学习

Oracle的学习心得和知识总结（三十）| OLTP 应用程序的合成工作负载生成器Lauca论文翻译及学习

目录结构 注&#xff1a;提前言明 本文借鉴了以下博主、书籍或网站的内容&#xff0c;其列表如下&#xff1a; 1、参考书籍&#xff1a;《Oracle Database SQL Language Reference》 2、参考书籍&#xff1a;《PostgreSQL中文手册》 3、EDB Postgres Advanced Server User Gui…
阅读更多...
Tomcat-指定启动jdk、修改使用的jdk版本

Tomcat-指定启动jdk、修改使用的jdk版本

修改tomcat配置文件setclasspath.sh 配置文件首行增加以下代码&#xff0c;指定启动的jdk&#xff1a; export JAVA_HOME/opt/softwares/jdk1.8.0_211/ export JRE_HOME/opt/softwares/jdk1.8.0_211/jre
阅读更多...
详解—C++ [异常]

详解—C++ [异常]

目录 一、C语言传统的处理错误的方式 二、C异常概念 三、异常的使用 3.1 异常的抛出和捕获 3.2 异常的重新抛出 3.3异常安全 3.4 异常规范 四、自定义异常体系 五、C标准库的异常体系 六、异常的优缺点 6.1、C异常的优点&#xff1a; 6.2、C异常的缺点&#xff1a;…
阅读更多...
Transformer的学习

Transformer的学习

文章目录 Transformer1.了解Seq2Seq任务2.Transformer 整体架构3.Encoder的运作方式4.Decoder的运作方式5.AT 与 NAT6.Encoder 和 Decoder 之间的互动7.Training Transformer 1.了解Seq2Seq任务 NLP 的问题&#xff0c;都可以看做是 QA&#xff08;Question Answering&#x…
阅读更多...
C语言程序设计·头歌实训合集

C语言程序设计·头歌实训合集

C语言程序设计实训 C语言程序设计编辑与调试环境 任何高级语言源程序都要“翻译”成机器语言&#xff0c;才能在机器上运行。“翻译”的方式有两种&#xff1a;一种是解释方式&#xff0c;即对源程序解释一句执行一句&#xff1b;另一种是编译方式&#xff0c;即通过编译系统…
阅读更多...
Python----进程的注意点

Python----进程的注意点

1. 进程的注意点介绍 进程之间不共享全局变量主进程会等待所有的子进程执行结束再结束 2. 进程之间不共享全局变量 import multiprocessing import time# 定义全局变量 g_list list()# 添加数据的任务 def add_data():for i in range(5):g_list.append(i)print("add:&…
阅读更多...
你在为其他知识付费平台做流量吗？

你在为其他知识付费平台做流量吗？

随着知识付费市场的蓬勃发展&#xff0c;越来越多的知识提供者选择将自己的课程放到各大知识付费平台上进行销售。然而&#xff0c;你是否意识到&#xff0c;你正在为这些平台做流量、做数据、做流水、做品牌&#xff0c;而卖出去的课程平台还要抽取你的佣金&#xff1f; 如果…
阅读更多...
全网好听的BGM都在这里下载，赶紧收藏好了

全网好听的BGM都在这里下载，赶紧收藏好了

无论是自媒体创作者还是从事视频剪辑工作的朋友&#xff0c;对于BGM的选择都很重要&#xff0c;一首适配的BGM能大大提升你作品的质量&#xff0c;还能让作品更优秀。哪里才能找到好听又免费的BGM&#xff1f;下面推荐几个我多年收藏的6个音效、音频素材网站&#xff0c;赶紧收…
阅读更多...
【LeetCode刷题笔记（8-3）】【Python】【接雨水】【双指针】【困难】

【LeetCode刷题笔记（8-3）】【Python】【接雨水】【双指针】【困难】

文章目录 引言接雨水题目描述提示 解决方案3&#xff1a;【双指针】结束语 接雨水 【LeetCode刷题笔记&#xff08;8-1&#xff09;】【Python】【接雨水】【动态规划】【困难】 【LeetCode刷题笔记&#xff08;8-2&#xff09;】【Python】【接雨水】【单调栈】【困难】 引言…
阅读更多...
MySQL数据库：表的约束

MySQL数据库：表的约束

目录 一. 空属性null 二. 默认值default 三. 列描述comment 四. 填充零zerofill 五. 主键primary key 六. 自增长auto_increment 七. 唯一键unique 八. 外键foreign key 一. 空属性null 对于表中的数据&#xff0c;如果在进行插入的时候不显示地给定值&#xff0c;那么…
阅读更多...
RabbitMQ入门指南(一)：初识与安装

RabbitMQ入门指南(一)：初识与安装

专栏导航 RabbitMQ入门指南 从零开始了解大数据 目录 专栏导航 前言 一、消息队列介绍 1.同步调用和异步调用 2.常见消息队列介绍 二、RabbitMQ简介及其安装步骤 1.RabbitMQ简介 2.RabbitMQ安装步骤&#xff08;使用Docker&#xff09; (1) 创建网络 (2) 使用Docker来…
阅读更多...
文件上传——后端

文件上传——后端

文件上传流程&#xff1a; 创建阿里云OSS&#xff08;对象存储服务&#xff09;的bucket 登录阿里云&#xff0c;并完成实名认证&#xff0c;地址&#xff1a;https://www.aliyun.com/. 可以通过搜索&#xff0c;进入以下页面&#xff1a; 点击立即使用后&#xff1a; 点击…
阅读更多...
Spring Boot3.1.6配置对应的Swagger

Spring Boot3.1.6配置对应的Swagger

1. pom.xml导入Swagger依赖 <!--swagger3--> <dependency><groupId>org.springdoc</groupId><artifactId>springdoc-openapi-starter-webmvc-ui</artifactId><version>2.0.2</version> </dependency> 2.创建SwaggerCo…
阅读更多...
【兔子王赠书第13期】AI绘画实战：Midjourney从新手到高手

【兔子王赠书第13期】AI绘画实战：Midjourney从新手到高手

文章目录 写在前面AI绘画推荐图书一本书读懂AI绘画关键点内容简介作者简介 推荐理由粉丝福利写在后面 写在前面 如今AI技术已经进入了我们的日常学习生活中&#xff0c;如何用一本书轻松玩转AI绘画&#xff0c;领略无限艺术可能呢&#xff1f; AI绘画 AI绘画是指利用人工智能…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023