java 锁升级_synchronized 底层如何实现？什么是锁升级、降级？

最新推荐文章于 2024-07-29 23:51:10 发布
最新推荐文章于 2024-07-29 23:51:10 发布
阅读量487 收藏 1
点赞数
文章标签： java 锁升级
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_30624835/article/details/114179545
版权
本文详细介绍了Java中`synchronized`关键字的底层实现，包括偏斜锁、轻量级锁和重量级锁。通过对象头的Mark Word分析锁的状态，解释了锁升级和降级的机制，以提升并发性能。
摘要由CSDN通过智能技术生成

synchronized 底层如何实现？什么是锁升级、降级？

synchronized 代码块是由一对 monitorenter/monitorexit 指令实现的，Monitor 对象是同步的基本实现单元。

在Java6之前， Monitor的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作。现代的( Oracle)JDK中，JVM对此进行了大刀阔斧地改进，提供了三种不同的 Monitor 实现，也就是常说的三种不同的锁：偏斜锁( Biased Locking)、轻量级锁和重量级锁，大大改进了其性能。

什么是锁升级，降级？

所谓的锁升级、降级，就是 JVM 优化 synchronized 运行的机制，当 JVM 监测到不同的竞争状况是，会自动切换到不同的锁实现。这种切换就是锁的升级、降级。

对象的结构

说偏向锁之前，需要理解对象的结构，对象由多部分构成的，对象头，属性字段、补齐区域等。所谓补齐区域是指如果对象总大小不是4字节的整数倍，会填充上一段内存地址使之成为整数倍。

偏向锁又和对象头密切相关，对象头这部分在对象的最前端，包含两部分或者三部分：Mark Words、Klass Words，如果对象是一个数组，那么还可能包含第三部分：数组的长度。Klass Word里面存的是一个地址，占32位或64位，是一个指向当前对象所属于的类的地址，可以通过这个地址获取到它的元数据信息。

Mark Word需要重点说一下，这里面主要包含对象的哈希值、年龄分代、hashcode、锁标志位等。

如果应用的对象过多，使用64位的指针将浪费大量内存。64位的JVM比32位的JVM多耗费50%的内存。 我们现在使用的64位 JVM会默认使用选项 +UseCompressedOops 开启指针压缩，将指针压缩至32位。

以64位操作系统为例，对象头存储内容图例

|--------------------------------------------------------------------------------------------------------------|

| Object Header (128 bits) |

|--------------------------------------------------------------------------------------------------------------|

| Mark Word (64 bits) | Klass Word (64 bits) |

|--------------------------------------------------------------------------------------------------------------|

| unused:25 | identity_hashcode:31 | unused:1 | age:4 | biased_lock:1 | lock:2 | OOP to metadata object | 无锁

|----------------------------------------------------------------------|--------|------------------------------|

| thread:54 | epoch:2 | unused:1 | age:4 | biased_lock:1 | lock:2 | OOP to metadata object | 偏向锁

|----------------------------------------------------------------------|--------|------------------------------|

| ptr_to_lock_record:62 | lock:2 | OOP to metadata object | 轻量锁

|----------------------------------------------------------------------|--------|------------------------------|

| ptr_to_heavyweight_monitor:62 | lock:2 | OOP to metadata object | 重量锁

|----------------------------------------------------------------------|--------|------------------------------|

| | lock:2 | OOP to metadata object | GC

|--------------------------------------------------------------------------------------------------------------|

对象头中的信息如何理解呢，举个例子

从该对象头中分析加锁信息，MarkWordk为0x0000700009b96910，二进制为0xb00000000 00000000 01111111 11110000 11001000 00000000 01010011 11101010。 倒数第三位为"0"，说明不是偏向锁状态，倒数两位为"10"，因此，是重量级锁状态，那么前面62位就是指向互斥量的指针。

basied_locklock状态001无锁101偏向锁000轻量级锁010重量级锁011GC标记age：Java GC标记位对象年龄。

identity_hashcode：对象标识Hash码，采用延迟加载技术。当对象使用HashCode()计算后，并会将结果写到该对象头中。当对象被锁定时，该值会移动到线程Monitor中。

thread：持有偏向锁的线程ID和其他信息。这个线程ID并不是JVM分配的线程ID号，和Java Thread中的ID是两个概念。

epoch：偏向时间戳。

ptr_to_lock_record：指向栈中锁记录的指针。

ptr_to_heavyweight_monitor：指向线程Monitor的指针。

无锁

A a = new A();

System.out.println(ClassLayout.parseInstance(a).toPrintable());

可以看到最后 00000001 basied_lock = 0, lock =01 表示无锁

JavaThread.synchronizestructure.A object internals:

OFFSET SIZE TYPE DESCRIPTION VALUE

0 4 (object header) 01 00 00 00 (00000001 00000000 00000000 00000000) (1)

4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)

8 4 (object header) 43 c0 00 20 (01000011 11000000 00000000 00100000) (536920131)

12 1 boolean A.flag false

13 3 (loss due to the next object alignment)

Instance size: 16 bytes

Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

偏斜锁

当没有竞争出现时，默认使用偏斜锁。 JVM 会利用 CAS 操作在对象头上的 Mark Word 部分设置线程 ID ，以表示对象偏向当前线程。所以并不涉及真正的互斥锁，这样做的假设是基于在很多应用场景中，大部分对象生命周期中最多会被一个线程锁定，使用偏斜锁可以降低无竟争开销。 测试代码：

Thread.sleep(5000);

A a = new A();

synchronized (a) {

System.out.println(ClassLayout.parseInstance(a).toPrintable());

}

运行结果：

JavaThread.synchronizestructure.A object internals:

OFFSET SIZE TYPE DESCRIPTION VALUE

0 4 (object header) 05 28 8d 02 (00000101 00101000 10001101 00000010) (42805253)

4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)

8 4 (object header) 43 c0 00 20 (01000011 11000000 00000000 00100000) (536920131)

12 1 boolean A.flag false

13 3 (loss due to the next object alignment)

Instance size: 16 bytes

Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

00000101 中 basied_lock = 1, lock =01 表示偏斜锁

轻量级锁

thread1中依旧输出偏向锁，主线程获取对象A时，thread1虽然已经退出同步代码块，但主线程和thread1仍然为锁的交替竞争关系。故此时主线程输出结果为轻量级锁。 测试代码：

Thread.sleep(5000);

A a = new A();

Thread thread1= new Thread(){

@Override

public void run() {

synchronized (a){

System.out.println("thread1 locking");

System.out.println(ClassLayout.parseInstance(a).toPrintable()); //偏向锁

}

}

};

thread1.start();

thread1.join();

Thread.sleep(10000);

synchronized (a){

System.out.println("main locking");

System.out.println(ClassLayout.parseInstance(a).toPrintable());//轻量锁

}

}

运行结果：

JavaThread.synchronizestructure.A object internals:

OFFSET SIZE TYPE DESCRIPTION VALUE

0 4 (object header) 05 40 e9 19 (00000101 01000000 11101001 00011001) (434716677)

4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)

8 4 (object header) a0 c0 00 20 (10100000 11000000 00000000 00100000) (536920224)

12 1 boolean A.flag false

13 3 (loss due to the next object alignment)

Instance size: 16 bytes

Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

main locking

JavaThread.synchronizestructure.A object internals:

OFFSET SIZE TYPE DESCRIPTION VALUE

0 4 (object header) 38 f6 c7 02 (00111000 11110110 11000111 00000010) (46659128)

4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)

8 4 (object header) a0 c0 00 20 (10100000 11000000 00000000 00100000) (536920224)

12 1 boolean A.flag false

13 3 (loss due to the next object alignment)

Instance size: 16 bytes

Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

00000101 依然是偏向锁，00111000 是轻量级锁

重量级锁

thread1 和 thread2 同时竞争对象a，此时输出结果为重量级锁

测试代码：

Thread.sleep(5000);

A a = new A();

Thread thread1 = new Thread(){

@Override

public void run() {

synchronized (a){

System.out.println("thread1 locking");

System.out.println(ClassLayout.parseInstance(a).toPrintable());

try {

//让线程晚点儿死亡，造成锁的竞争

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

Thread thread2 = new Thread(){

@Override

public void run() {

synchronized (a){

System.out.println("thread2 locking");

System.out.println(ClassLayout.parseInstance(a).toPrintable());

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

thread1.start();

thread2.start();

运行结果：

thread2 locking

JavaThread.synchronizestructure.A object internals:

OFFSET SIZE TYPE DESCRIPTION VALUE

0 4 (object header) 7a f5 99 17 (01111010 11110101 10011001 00010111) (395965818)

4 4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0)

8 4 (object header) 62 c1 00 20 (01100010 11000001 00000000 00100000) (536920418)

12 1 boolean A.flag false

13 3 (loss due to the next object alignment)

Instance size: 16 bytes

Space losses: 0 bytes internal + 3 bytes external = 3 bytes total

01111010 basied_lock = 0 lock=10 重量级锁

GZ号：程序员开发者社区

大师的菜
关注
synchronized 底层如何实现？什么是锁升级、降级？
王小明的专栏
05-06 475
synchronized 底层如何实现？什么是锁升级、降级？ synchronized 代码块是由一对 monitorenter/monitorexit 指令实现的，Monitor 对象是同步的基本实现单元。 https://docs.oracle.com/javase/specs/jls/se10/html/jls-8.html#d5e13622 在Java6之前， Monitor的实现完全...
synchronized 底层如何实现？什么是锁的升级、降级？
数字成都
04-13 7083
在 Java 6 之前，Monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作。 现代的（Oracle）JDK 中，JVM 对此进行了大刀阔斧地改进，提供了三种不同的 Monitor 实现，也就是常说的三种不同的锁：偏斜锁（Biased Locking）、轻量级锁和重量级锁，大大进了其性能。 首先，我们要知道对象在内存中的布局：...
synchronized底层如何实现？什么是锁的升级、降级？
雪雪
04-26 341
我在对比和分析了 synchronized 和 ReentrantLock，算是专栏进入并发编程阶段的热身，相信你已经对线程安全，以及如何使用基本的同步机制有了基础，今天我们将深入了解 synchronize 底层机制，分析其他锁实现和应用场景。今天我要问你的问题是 ，synchronized 底层如何实现？什么是锁的升级、降级？
Synchronized的锁升级过程是怎样的？
最新发布
weixin_45102820的博客
07-29 905
关键字加到static静态方法和代码块上都是是给 Class 类上锁；关键字加到实例方法上是给对象实例上锁；尽量不要使用，因为 JVM 中，字符串常量池具有缓存功能，多个线程使用相同的字符串值，实际使用的是同一个对象。
读锁应该插队吗？什么是读写锁的升降级？
vincent_wen0766的博客
09-13 299
读锁插队策略 ReentrantReadWriteLock 可以设置为公平或者非公平，代码如下 // 公平锁 ReentrantReadWriteLockreentrantReadWriteLock=newReentrantReadWriteLock(true); // 非公平锁 ReentrantReadWriteLockreentrantReadWriteLock=newReentrantReadWriteLock(false); 如果是公平锁，我们就在构造函数的参数中传...
java 锁降级 知乎_锁升级 锁降级
weixin_30830643的博客
02-25 611
首先说明一下，锁升级和锁降级说的根本不是一个事情，锁升级是synchronized关键字在jdk1.6之后做的优化，锁降级是为了保证数据的可见性在添加了写锁后再添加一道读锁，锁降级请参考链接1。本文主要针对锁升级介绍。之前介绍过synchronized关键字，synchronized关键字可以锁类，锁方法和锁代码块，有关synchronized关键字的使用可以参考链接2，synchronized锁...
第16讲 synchronized底层如何实现？什么是锁的升级、降级？1
08-03
在深入讲解 `synchronized` 底层实现之前，我们先回顾一下锁的升级和降级的概念。 锁的升级和降级是 JVM 为了优化 `synchronized` 性能而引入的一种策略。在低竞争情况下，JVM 会尽量减少锁带来的开销，从而提高...
第16讲synchronized底层如何实现？什么是锁...1
08-03
在Java 6之后，为了提高性能，JVM引入了锁的升级和降级机制，使得synchronized在不同竞争情况下可以智能地选择合适的锁实现。 1. **偏斜锁（Biased Locking）**：在没有竞争的情况下，synchronized会尝试使用偏斜锁...
Java 锁升级（锁膨胀）、锁降级
haoranhaoshi的博客
09-10 2332
锁升级：偏向锁、轻量级锁、重量级锁的过渡。 https://blog.csdn.net/haoranhaoshi/article/details/92388612 优先尝试低级锁，不能适用，就升级锁。线程获取到不被其他线程获取的监视类或对象，监视类或对象头部记录线程ID，线程退出对监视类或对象的获取时直接退出，是偏向锁。如果有其他线程来获取监视类或对象，发现头部记录的线程ID不是自己的ID（https://blog.csdn.net/haoranhaoshi/article/details/10850.
【Java进阶】synchronized底层如何实现？什么是锁的升级、降级？
兴趣是最好的老师
07-15 808
全面分析了 synchronized 相关实现和内部运行机制，简单介绍了并发包中提供的其他显式锁，并结合样例代码介绍了其使用方法，希望对你有所帮助。
Java中的锁：类型，比较，升级与降级
qq_39508627的博客
10-30 248
在Java中，锁的升级与降级是指在使用过程中对锁的变更。具体来说，锁升级是指将一个低级别的锁升级为高级别的锁，而锁降级是指将一个高级别的锁降级为低级别的锁。Java提供了多种类型的锁，包括内置的synchronized关键字、ReentrantLock、ReadWriteLock等。本文将详细介绍这些锁的类型，比较它们的性能和适用场景，并探讨锁的升级与降级。它提供了一种更加灵活的锁控制方式，与synchronized关键字相比，ReentrantLock具有更多的功能和配置选项。
Java锁的升降级及synchoronized优化
weixin_33697898的博客
08-18 327
JavaSE 减少了获得锁和释放锁带来的性能消耗，引入了"偏向锁"和"轻量级锁"。在javaSe 1.6中，锁一共4种状态，级别从低到高依次是：无锁状态，偏向锁状态，轻量级锁状态，重量级锁状态，这个几个状态会随着竞争状态进行升级。锁可以升级但不能降级，意味者偏向锁升级成轻量级锁不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高获得锁和释放锁的效率。 1.偏向锁 在多数...
synchronized底层是如何实现的？什么又是锁升级？什么是降级？
m0_70026455的博客
11-28 337
synchronized底层如何实现？
synchronized 底层实现以及什么是锁的升级、降级
zhangguozhangyue的博客
09-11 4619
synchronized 代码块是 由一对儿 monitorenter/monitorexit 指令实现的，Monitor 对象是同步的基本实 现单元。 在 Java 6 之前，Monitor 的实现完全是依靠操作系统内部的互斥锁，因为需要 进行用户态到内核态的切换，所以同步操作是一个无差别的重量级操作。 现代的（Oracle）JDK 中，JVM 对此进行了大刀阔斧地改进，提供了三种不同 的 Mo...
Java并发编程之锁的升级
Yangyeon_的博客
08-10 2227
如果多个线程轮流获取一个锁，但是每次获取锁的时候都很顺利，没有发生阻塞，那么就不存在锁竞争。只有当某线程尝试获取锁的时候，发现该锁已经被占用，只能等待其释放，这才发生了锁竞争。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值