浅析synchronized锁升级的原理与实现 2

于 2024-09-01 15:44:11 发布
阅读量462 收藏 7
点赞数 7
分类专栏： java 文章标签： 服务器 java juc 锁机制、 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45956730/article/details/141785098
版权

本文内容是继我的上篇博客 浅析synchronized锁升级的原理与实现 1-CSDN博客

目录

 各状态锁的升级场景

无锁 --> 轻量级锁

偏向锁 --> 轻量级锁

偏向锁 --> 重量级锁

轻量级锁 --> 重量级锁

总结

 各状态锁的升级场景

下面我们结合代码看下各状态锁的升级场景。

需要添加JOL包，用来查看对象头信息。另外，采用JOL输出的对象头markword是16进制的，需要转换成64位的2进制来看。

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

无锁 --> 轻量级锁

无锁升级到轻量级锁有两种情况。

 1）第一种，关闭偏向锁，执行时增加JVM参数：-XX:-UseBiasedLocking。

public void lockUpgradeTest1() {
    Object obj = new Object();
    System.out.println("未开启偏向锁，对象信息");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    synchronized (obj) {
        System.out.println("已获取到锁信息");
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
    System.out.println("已释放锁信息");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
}

在这段代码中，首先创建了一个 Object 对象 obj。然后使用 ClassLayout.parseInstance(obj).toPrintable() 打印出该对象的内存布局。这段输出会显示对象在未加锁状态下的内存布局。在进入 synchronized 块时，线程获取了 obj 的锁。此时，会打印该对象在加锁状态下的内存布局。在 synchronized 块退出后，线程会释放锁，再次打印该对象的内存布局。

运行结果如下， 

未开启偏向锁，对象信息
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
已获取到锁信息
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000000336f2b0 (thin lock: 0x000000000336f2b0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
已释放锁信息
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

关闭偏向锁的情况下，对象加锁之前，对象头markword是0x0000000000000001换算成二进制末尾三位是001，即偏向锁标识为0，锁标识为01，是无锁状态。

加锁成功后，执行同步代码块，对象头markword是0x000000000336f2b0换算成二进制末尾两位是00，即锁标识为00，是轻量级锁状态。

最后，在执行完同步代码块后，再次打印对象头信息，对象头markword是0x0000000000000001换算成二进制末尾三位是001，即偏向锁标识为0，锁标识为01，是无锁状态，说明轻量级锁在执行完同步代码块后进行了锁的释放。

2） 第二种，默认情况下，在偏向锁延迟时间之前获取锁。

public void lockUpgradeTest2() {
    Object obj = new Object();
    System.out.println("开启偏向锁，偏向锁延迟时间前，对象信息");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    synchronized (obj) {
        System.out.println("已获取到锁信息");
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
    System.out.println("开启偏向锁，已释放锁信息");
    System.out.println(ClassLayout.parseInstance(obj).toPrintable());
}

在这段代码中，首先创建了一个 Object 对象 obj。然后使用 ClassLayout.parseInstance(obj).toPrintable() 打印出该对象的内存布局。这段输出会显示对象在未加锁状态下的内存布局。在进入 synchronized 块时，线程获取了 obj 的锁。此时，会打印该对象在加锁状态下的内存布局。在 synchronized 块退出后，线程会释放锁，再次打印该对象的内存布局。

运行结果如下，

开启偏向锁，偏向锁延迟时间前，对象信息
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
已获取到锁信息
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000000316f390 (thin lock: 0x000000000316f390)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
开启偏向锁，已释放锁信息
java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

使用默认的偏向锁配置，JVM启动4秒后才启动偏向锁，所以JVM启动时就打印并获取锁信息，效果跟第一种一样，markword解释同上。

关闭偏向锁的情况下，对象加锁之前，对象头markword是0x0000000000000001换算成二进制末尾三位是001，即偏向锁标识为0，锁标识为01，是无锁状态。

加锁成功后，执行同步代码块，对象头markword是0x000000000316f390换算成二进制末尾两位也是00，即锁标识为00，是轻量级锁状态。

最后，在执行完同步代码块后，再次打印对象头信息，对象头markword是0x0000000000000001换算成二进制末尾三位是001，即偏向锁标识为0，锁标识为01，是无锁状态，说明轻量级锁在执行完同步代码块后进行了锁的释放。

偏向锁 --> 轻量级锁

public void lockUpgradeTest3() {
    // JVM默认4秒后才可以偏向锁，所以这里休眠5秒，锁对象就是偏向锁了
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    Object object = new Object();
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "开启偏向锁，偏向锁延迟时间后，对象信息" + ClassLayout.parseInstance(object).toPrintable());
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
        }
        System.out.println(Thread.currentThread().getName() + "开启偏向锁，已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
    }, "t1");
    t1.start();
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    Thread t2 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "开启偏向锁，偏向锁延迟时间后，对象信息" + ClassLayout.parseInstance(object).toPrintable());
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
        }
        System.out.println(Thread.currentThread().getName() + "开启偏向锁，已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
    }, "t2");
    t2.start();
}

在 Java 中，偏向锁的默认启用有一定的延迟（通常是 4 秒），即 JVM 会在应用启动后的几秒钟内不启用偏向锁。通过 Thread.sleep(5000)，确保程序等待 5 秒，以保证接下来创建的对象能够开启偏向锁。

然后，创建一个新的 Object 实例 object。这个对象将作为锁对象，供后续两个线程进行锁的获取和释放操作。

t1 线程在启动后，首先打印对象的内存布局信息，此时 object 应该已经启用了偏向锁。进入 synchronized (object) 代码块时，t1 线程获取到 object 的偏向锁，并打印锁定后的对象状态。退出 synchronized 代码块后，t1 释放锁，并再次打印对象的内存布局信息。

t1 线程启动后，程序再等待 3 秒，然后启动 t2 线程。t2 线程的执行逻辑与 t1 类似，但它在稍后启动，并且会检查在 t1 执行后 object 的锁状态。如果 t1 持有偏向锁且没有发生锁升级，t2 线程尝试获取锁时会触发偏向锁撤销，可能导致锁升级。

运行结果有两种可能：

1）第一种：

t1开启偏向锁，偏向锁延迟时间后，对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001fbb3005 (biased: 0x000000000007eecc; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1开启偏向锁，已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001fbb3005 (biased: 0x000000000007eecc; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2开启偏向锁，偏向锁延迟时间后，对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001fbb3005 (biased: 0x000000000007eecc; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020f7f2d0 (thin lock: 0x0000000020f7f2d0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2开启偏向锁，已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

启动JVM，默认4秒后开启偏向锁，这里休眠了5秒，保证JVM开启偏向锁，然后创建了对象，对象头markword信息0x0000000000000005换算成二进制后三位是101，偏向锁标识为1，锁标识为01，为偏向锁状态，偏向线程ID是0，说明这是初始偏向状态。

t1先获取到锁进入同步代码块后，markword变成0x000000001fbb3005转换成二进制为11111101110110011000000000101（前面补0直到长度是64位），末尾三位依然是101，还是偏向锁，只不过前54位将对应的操作系统线程ID写到偏向线程ID里了。

同步代码块执行完成后，markword依然没变，说明偏向锁状态不会自动释放锁，需要等其他线程来竞争锁才走偏向锁撤销流程。

t2线程开始执行时锁对象markword是0x000000001fbb3005，说明偏向锁偏向了t1对应的操作系统线程。

等t1释放锁，t2获取到锁进入同步代码块时，对象锁markword是0x0000000020f7f2d0，换算成二进制为100000111101111111001011010000（前面补0直到长度是64位），末尾两位是00，锁已经变成轻量级锁了，锁的指针也变了，是指向t2线程栈中的Lock Record记录了。

等t2线程释放锁后，对象锁末尾是001，说明是无锁状态了，轻量级锁会自动释放锁。

2）第二种

t1开启偏向锁，偏向锁延迟时间后，对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002031d805 (biased: 0x0000000000080c76; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1开启偏向锁，已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002031d805 (biased: 0x0000000000080c76; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2开启偏向锁，偏向锁延迟时间后，对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002031d805 (biased: 0x0000000000080c76; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002031d805 (biased: 0x0000000000080c76; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2开启偏向锁，已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002031d805 (biased: 0x0000000000080c76; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

t1线程正常获取锁，锁状态是偏向锁。

执行完同步代码块后锁还是偏向锁，说明偏向锁不随执行同步代码块的结束而释放锁。

t2线程拿到锁是偏向锁，获取到锁依然是偏向锁，而没有升级到轻量级锁，说明线程间锁没有竞争的情况下，依然保持偏向锁，这样效率会更高。

偏向锁 --> 重量级锁

public void lockUpgradeTest4() {
    // JVM默认4秒后才可以偏向锁，所以这里休眠5秒，锁对象就是偏向锁了
    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    Object object = new Object();
    Thread t1 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "加锁前对象信息" + ClassLayout.parseInstance(object).toPrintable());
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
            try {
                // 让t2线程启动后并竞争锁
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.println(Thread.currentThread().getName() + "已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
    }, "t1");
    t1.start();
    try {
        // 让t1线程先启动并拿到锁
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    Thread t2 = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "加锁前对象信息" + ClassLayout.parseInstance(object).toPrintable());
        synchronized (object) {
            System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
        }
        System.out.println(Thread.currentThread().getName() + "已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
    }, "t2");
    t2.start();
}

在 Java 中，偏向锁默认有一个启用延迟（通常为4秒）。代码通过 Thread.sleep(5000)，确保程序等待5秒钟后创建的 object 对象已经启用了偏向锁。

创建一个新的 Object 实例 object，该对象将用于后续线程的锁操作。

t1 线程首先打印 object 的内存布局信息，显示对象在未加锁状态下的布局（可能是偏向锁状态）。进入 synchronized (object) 块后，t1 获取到 object 的锁（此时锁可能为偏向锁），并再次打印对象的内存布局。t1 线程在持有锁的状态下，通过 Thread.sleep(3000) 让线程休眠3秒钟，模拟在锁内执行一些操作，同时为 t2 线程竞争锁创造条件。退出 synchronized 块后，t1 释放锁，并打印对象的内存布局信息。

在 t1 启动并持有锁3秒后，主线程通过 Thread.sleep(3000) 等待后再启动 t2，确保 t1 已经获取了 object 的锁。t2 线程的执行逻辑与 t1 类似，但由于 t1 持有锁，t2 必须等待 t1 释放锁后才能继续。t2 在获取到 object 的锁后，打印锁定前后的对象内存布局信息。t2 退出 synchronized 块后，释放锁并打印对象的内存布局信息。

运行结果如下所示，

t1加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020993805 (biased: 0x000000000008264e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020993805 (biased: 0x000000000008264e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d2c6c2a (fat lock: 0x000000001d2c6c2a)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d2c6c2a (fat lock: 0x000000001d2c6c2a)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000001 (non-biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

程序先休眠5秒保证偏向锁开启，然后t1线程先启动并成功获取到锁，t1获取到锁之前对象markword是偏向状态但偏向线程ID是0，t1获取到锁之后markword里有了偏向线程ID，也就是t1线程对应的操作系统线程ID。

t2线程获取锁之前，对象锁已经是偏向锁并偏向t1对应的线程。

t2线程获取锁时t1已经持有锁并没有释放，锁未释放其他线程再竞争锁，这时会发生锁升级，由偏向锁升级成重量级锁，所以t1释放锁跟t2获取到锁时，对象头的markword是0x000000001d2c6c2a，转换成二进制11101001011000110110000101010（前后补0到够64位），最后两位是10，表示重量级锁，前面的62存的是指向堆中跟monitor对应锁对象的指针。

轻量级锁 --> 重量级锁

public void lockUpgradeTest5() {
        // JVM默认4秒后才可以偏向锁，所以这里休眠5秒，锁对象就是偏向锁了
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Object object = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "加锁前对象信息" + ClassLayout.parseInstance(object).toPrintable());
            synchronized (object) {
                System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
                try {
                    // 让t2线程启动后并竞争锁
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println(Thread.currentThread().getName() + "已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
        }, "t1");
        t1.start();
        try {
            // 让t1线程先启动并拿到锁
            t1.join();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        Thread t2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "加锁前对象信息" + ClassLayout.parseInstance(object).toPrintable());
            synchronized (object) {
                System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
            }
            System.out.println(Thread.currentThread().getName() + "已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
        }, "t2");
        t2.start();
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "加锁前对象信息" + ClassLayout.parseInstance(object).toPrintable());
                synchronized (object) {
                    System.out.println(Thread.currentThread().getName() + "已获取到锁信息" + ClassLayout.parseInstance(object).toPrintable());
                }
                System.out.println(Thread.currentThread().getName() + "已释放锁信息" + ClassLayout.parseInstance(object).toPrintable());
            }, "t3_" + i).start();
        }
 
    }

在 Java 中，偏向锁默认启用时存在延迟（通常为4秒），目的是避免在应用刚启动时频繁分配偏向锁。通过 Thread.sleep(5000) 确保应用等待5秒钟，从而偏向锁机制可以生效。

创建一个新的 Object 实例 object，这个对象将被多个线程用于同步锁的竞争。

t1 线程首先打印对象的内存布局，显示对象在未加锁状态下的布局（通常是偏向锁状态）。t1 获取对象锁后，进入 synchronized 块并打印加锁后的对象内存布局。t1 持有锁期间休眠3秒，以模拟锁内操作并确保其他线程（如 t2）在这段时间内尝试获取锁。退出同步块后，t1 释放锁，并打印对象的内存布局信息。

使用 t1.join() 确保 t2 在 t1 执行完毕后才启动，这样可以观察锁的释放与重新获取的过程。t2 的执行逻辑与 t1 类似，但由于 t1 已经对 object 进行了操作，锁状态可能已经发生了改变（如从偏向锁升级到轻量级锁）。t2 进入 synchronized 块后获取锁，并在释放锁时再次打印对象的内存布局信息。

启动三个 t3 线程 (t3_0, t3_1, t3_2)，每个线程在运行时都尝试获取 object 的锁。这些线程的竞争行为可能导致锁的升级，特别是在多个线程快速尝试获取同一个对象锁的情况下，锁有可能从轻量级锁升级到重量级锁。每个 t3 线程在进入和退出同步块时都会打印对象的内存布局，显示锁状态的变化。

运行结果如下所示，

注意：这里t2线程也有可能获取到的锁是偏向锁，无竞争的情况下，这取决于线程的执行情况。这里我们以t2获取到轻量级锁，讲解轻量级锁升级到重量级锁的过程。

t1加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020e1b805 (biased: 0x000000000008386e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t1已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020e1b805 (biased: 0x000000000008386e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020e1b805 (biased: 0x000000000008386e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_0加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020e1b805 (biased: 0x000000000008386e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_1加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000020e1b805 (biased: 0x000000000008386e; epoch: 0; age: 0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002270f1d0 (thin lock: 0x000000002270f1d0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_2加锁前对象信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000002270f1d0 (thin lock: 0x000000002270f1d0)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_1已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t2已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_1已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_0已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_0已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_2已获取到锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
 
t3_2已释放锁信息java.lang.Object object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000001d0356da (fat lock: 0x000000001d0356da)
  8   4        (object header: class)    0xf80001e5
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

t1线程加锁执行代码块后，锁状态是偏向锁，t1在同步代码块里让休眠了3秒目的是让t2线程起来并竞争锁。

然后t1线程执行完同步代码块，锁状态还是偏向锁。

这时候for循环的3个线程也启动起来争抢锁，t2线程先启动获取到锁为轻量级锁，for循环里启动的3个线程在获取同步锁前，我们看到打印的锁状态有的是偏向锁、有的是轻量级锁，说明在t2线程加锁成功前还是偏向锁，t2加锁后就成轻量级锁了。

然后for循环的3个线程相继获取到锁，发现锁已经升级到重量级锁了，对象头markword是0x000000001d0356da，换成二进制：11101000000110101011011011010（前面补齐0到够64位），末尾两位锁状态是10，表示重量级锁。

总结

synchronized关键字是Java中常用的线程同步机制，其具备锁升级的特性，可以根据竞争的程度和锁的状态进行自动切换。锁升级通过无锁、偏向锁、轻量级锁和重量级锁四种状态的转换，以提高并发性能。在实际开发中，我们应该了解锁升级的原理，并根据具体场景进行合理的锁设计和优化，以实现高效且安全的多线程编程。

随着jdk版本的升级，JVM底层的实现持续优化，版本的不同伴随着参数使用及默认配置的不同，但总之JVM层对synchronized的优化效率越来越高，所以不应该再把synchronized同步当重量级锁来看。

其实本文介绍了锁升级的主要过程，关于synchronized还有锁消除、锁粗化的优化手段，使得synchronized性能在某些场景应用下，可能会比JUC包底下的Lock相关锁效率更高。
另外synchronized锁原理、优化、使用远不止本文说的这么多，感兴趣的可进一步探索。

转载自https://www.cnblogs.com/star95/p/17542850.html

水w
关注
  • 7
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 617
浅析synchronized锁升级的原理与实现
浅析synchronized锁升级的原理与实现
Gefangenes的博客
07-13 233
synchronized关键字是Java中常用的线程同步机制，其具备锁升级的特性，可以根据竞争的程度和锁的状态进行自动切换。锁升级通过无锁、偏向锁、轻量级锁和重量级锁四种状态的转换，以提高并发性能。在实际开发中，我们应该了解锁升级的原理，并根据具体场景进行合理的锁设计和优化，以实现高效且安全的多线程编程。
浅析 synchronized 底层实现与锁相关 | Java
petterp的博客
06-24 291
引言 一切的最开始都是源自为什么？ 为什么加了锁 synchronized 关键字，就可以实现同步? synchronized 底层到底做了什么优化？ Java 中的各种锁及锁膨胀？ 用户态、内核态与上下文切换到底是什么鬼？ 什么叫自旋锁，它与 CAS 的关系？ 对象头是什么玩意，什么又是 MarkWord ? 概述 synchronizrd 是开发中解决同步问题中最常见，也是最简单的一种方法。从最开始学习并发编程，我们都知道，只要加上这个 synchronizrd 关键字，就可以很大程度上轻松解决
浅析synchronized底层实现与锁相关
郭霖
07-09 167
/ 今日科技快讯 /刚宣布转型更名的社区团购平台“蜜橙生活”（原名“同程生活”），于7月7日晚间再度发布公告称，“几年来因经营不善，虽经多方努力，但仍然无法摆脱经营困境。公司决定申...
面试必备java synchronized锁的升级
aaaak_的博客
03-16 1883
首先祭出下图，上图是线程获取锁和锁升级的基本流程(来自 这里 1 了解 synchronized synchronized 是 Java 中的关键字，是利用锁的机制来实现同步的。是Java内置的机制，是JVM层面的。 jdk 1.6以前synchronized 关键字只表示重量级锁。 在jdk1.6开始 ,对锁的实现引入了大量的优化，如自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁等技术...
synchronized关键字与volatile原理浅析
气派的欠账包店
08-11 723
synchronized关键字与volatile关键字可以说是Java多线程的基础，无论是各种同步锁，还是我们所遇到的线程安全问题，都与这两个关键字有联系。 Synchronized Synchronized关键字我们经常用来执行线程间的互斥操作，使用示例如下： int x; public synchronized void setX(int x) { ...
java并发——synchronized浅析
学习印记 Learning imprint
10-07 173
原理部分内容可以直接看这篇文章深入理解Java并发之synchronized实现原理 synchronized 用法 它的修饰对象有几种： 修饰一个类，其作用的范围是synchronized后面括号括起来的部分， 作用的对象是这个类的所有对象。 class ClassName { public void method() { synchronized(ClassName.class) { // todo } } } 修饰一个方法，被修饰的方法称为
synchronized关键字浅析
weixin_41047933的博客
01-23 263
六.线程8锁 思路： 线程 操作 共享资源 1）创建资源类，在资源类中定义线程操作方法，根据需要添加同步锁或同步代码块 2）创建线程对象，使用线程对象调用响应的同步方法 对象锁和类锁定义： 对象锁： 1）对象锁也叫方法锁，是针对一个对象实例的，它只在该对象的某个内存位置声明一个标识该对象是否拥有锁，所有它只会锁住当前的对象，而并不会对其他对象实例的锁产生任何影响，不同对象访问同...
Synchronized浅析
h13245的博客
07-09 221
简单分析了Synchronized的实现原理及如何简单运用
Java并发编程的艺术 2.2 synchronized的实现原理与应用
yzpbright的博客
04-11 168
参考： [1] Java特种兵，3.5 - 浅析Java对象的内存结构 [2] Java并发编程的艺术，2.2.1 - Java对象头 [3] 深入理解Java虚拟机，2.3.2 - 对象的内存布局 java对象在内存中的结构（HotSpot虚拟机） Java对象结构与锁实现原理及MarkWord详解 JVM——深入分析对象的内存布局 ...
Android性能优化(6)：浅析类加载机制与热修复技术
老蒋也疯狂
12-29 3468
文章目录1. 类加载与反射1.1 类加载机制1.1.1 类加载器1.1.1.1 Java中的ClassLoader1.1.1.2 Android中的ClassLoader1.1.2 双亲委托模式1.1.3 ClassLoader的加载过程1.1.4 类的链接1.1.5 类的初始化1.2 Java反射机制2. 热修复技术2.1 热修复方案2.1.1 Tinker2.1.2 QZone超级补丁2.1...
浅析HashMap与ConcurrentHashMap的线程安全性
热门推荐
Miracle_shen的博客
06-15 2万+
本文要解决的问题： 最近无意中发现有很多对Map尤其是HashMap的线程安全性的话题讨论，在我的理解中，对HashMap的理解中也就知道它是线程不安全的，以及HashMap的底层算法采用了链地址法来解决哈希冲突的知识，但是对其线程安全性的认知有限，故写这篇博客的目的就是让和我一样对这块内容不熟悉的小伙伴有一个对HashMap更深的认知。 哈希表 在数据结构中有一
Java从零开始学多线程——6.Java 锁 Lock AbstractQueuedSynchronizer ReentrantLock acquireQueued NonfairSync tryA
JAVA求生之路——博主406766467
12-30 190
????锁的分类 自旋锁： 线程状态及上下文切换消耗系统资源，当访问共享资源的时间短，频繁上下文切换不值得。jvm实现，使线程在没获得锁的时候，不被挂起，转而执行空循环，循环几次之后，如果还没能获得锁，则被挂起 意思就是，当别的线程拿到锁进入方法执行的时候，别的锁进不来，但是他不能被挂起，开始执行空的for循环防止被挂起，如果循环完毕还没有得到锁，那么就会被挂起。 //自旋锁 public class Lock{ private boolean isLocked = false;
Java多线程5—ReentrantLock与Condition
clyss1234的博客
09-29 654
文章目录1. ReentrantLock重入锁1.1 ReentrantLock源码解析1.1.1 lock操作1.1.2 release操作2. synchronized和Reetrantlock的区别3. Condition及其介绍3.1 Condition的介绍3.2 Condition在AQS中的使用3.3 Condition在阻塞队列中的实现4. [阻塞和唤醒线程——LockSupport功能简介及原理浅析](https://www.cnblogs.com/takumicx/p/9328459.h
Android O实现限制自启&&限制后台&&杀活方案
b178903294的博客
04-04 2351
由 b178903294创建, 最后修改于12月 30, 2020 上回书说到android的powersave lowmemorykiller 等的后台清理机制，与系统如何保证应用不被杀掉的保活方案。我们为了自己的应用能够常驻后台提供了系统保活的机制。那么其他三防应用为了自己能够永生，各种手段无所不用其极，绕过各种系统的杀活机制来达到常驻后台干些见不得人的勾当。所以我们常常见到系统运行的好好的突然各种弹窗，突然的cpu占用飙升猝不及防的卡死········ 即使我们信任的各种学习app后台罪行也是罄..
微服务CI/CD实践（二）服务器先决软件安装
lbmydream的博客
08-28 934
微服务CI/CD实践系列： 微服务CI/CD实践（一）环境准备及虚拟机创建 微服务CI/CD实践（二）服务器先决准备 微服务CI/CD实践（三）gitlab部署 微服务CI/CD实践（四）nexus3部署 微服务CI/CD实践（五）数据库,redis,nacos等基础中间件部署 微服务CI/CD实践（六）Jenkins部署 微服务CI/CD实践（七）Server服务器环境初始化 微服务CI/CD实践（八）Jenkins + Dokcer 部署微服务后端项目 微服务CI/CD实践（九）Jenkins +
并发服务器
m0_71459026的博客
08-27 343
1.阻塞IO：fgets、scanf、read、recv、getchar。实现步骤：获取原文件描述符的属性->增加非阻塞属性->设置新属性。1.单循环服务器：同一时刻，只能处理一个客户端的任务；2.并发服务器：同一时刻，可以处理多个客户端的任务；：文件描述符，指向要进行操作的打开文件的描述符。（1）异步通知的IO方式，节省CPU；（1）实现多个IO同步的效果。，则它是要设置的值；（1）多个IO复用一个进程;（1）使用轮询的方法实现。（2）只能监测少量IO；（2）cpu占有率低。（2）cpu占有率高。
Nginx: 负载均衡场景下上游服务器异常时的容错机制
最新发布
Wang的专栏
08-28 1386
Post请求，它就是一个非幂等的 http 请求方法，因为可能会在后端服务器上创建一些资源。所谓幂等的请求, 是指这个请求发出去之后，无论请求多少次，得到的结果通常是一致的。默认值： proxy_next_upstream error timeout;非幂等请求，可能对服务器造成不可预见的一些错误，在某些场景下是很危险的。2 ）proxy_next_upstream_timeout 指令。3 ）proxy_next_upstream_tries 指令。1 ）proxy_next_upstream 指令。
何为大模型服务器？如何明智地挑选？
HPC_Evan的博客
08-27 1201
拥有完备的 CUDA 环境、丰富多样的应用软件，如 TensorFlow、Pytorch 等，能够满足不同类型的模型训练需求，还有强大实用的函数库以及稳定可靠的 Ubuntu 22.04 LTS 64 位服务器版操作系统。对于企业而言，无论是优化生产流程的预测模型训练，还是提升客户体验的个性化推荐系统开发，这两款机型都能凭借出色的性能和稳定的运行，为企业节省时间和成本，提高市场竞争力。它们所具备的完善的软件和硬件配置，就像是为您精心打造的一把利剑，助您在大模型训练的道路上披荆斩棘，勇往直前。
synchronized实现原理与锁升级
04-10
Synchronized是Java中用于保证多个线程同步执行的一种机制，其实现原理是在代码块或方法上加锁。当一个线程进入被synchronized关键字标注的代码块或方法时，该线程会尝试去获取锁，如果锁没有被其他线程获取，则该线程获取到锁并执行代码；否则该线程会被阻塞，直到可以获取锁为止。 锁升级是指synchronized在不同的应用场景下会使用不同的锁来提升性能。在Java 6之前，synchronized关键字只有重量级锁，即每次都需要在内存中申请一个锁对象并将其标识为被锁住，锁的实现方式是通过操作系统调用加锁解锁。在Java 6之后，synchronized使用了轻量级锁、自旋锁和偏向锁等几种机制来提升性能。 总之，synchronized是Java中用于保证线程同步执行的机制，同时它的实现方式和锁升级机制随着JDK版本不断发展和优化。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水w

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值