synchronized底层原理深入剖析！object和锁相关的属性方法？锁对象为class的时候锁信息储存在哪里？Monitor 机制？

最新推荐文章于 2025-04-24 14:54:22 发布
最新推荐文章于 2025-04-24 14:54:22 发布
阅读量840 收藏 18
点赞数 12
CC 4.0 BY-SA版权
分类专栏： java并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45899526/article/details/146094624

synchronized底层原理深入剖析

synchronized关键字是实现线程同步的核心机制，其底层原理涉及对象头结构、Monitor监视器、锁升级策略以及JVM优化策略。

一、对象头与锁状态存储
每个Java对象在内存中由对象头（Header）、实例数据和对齐填充组成，锁信息存储在对象头的Mark Word字段中。
Mark Word结构（64位JVM为例）：

锁状态存储内容（64位）
无锁哈希码（31位）、分代年龄（4位）、锁标志位（01）
偏向锁线程ID（54位）、Epoch（2位）、锁标志位（01）
轻量级锁指向栈中锁记录的指针（62位）、锁标志位（00）
重量级锁指向Monitor的指针（62位）、锁标志位（10）
  • 锁标志位：标识当前锁状态（01/00/10），决定Mark Word的解析方式。

二、Monitor监视器机制
每个对象关联一个Monitor（由C++实现的ObjectMonitor结构），其核心组成：

  1. Owner：持有锁的线程，初始为NULL。
  2. EntryList：竞争锁失败的线程队列（阻塞态）。
  3. WaitSet：调用wait()后释放锁的线程队列（等待唤醒）。

工作流程：

  1. 线程通过monitorenter指令尝试获取锁：
    • 若Owner为空，CAS设置Owner为当前线程，_recursions计数器置1（支持重入）。
    • 若Owner是当前线程，_recursions计数器递增。
    • 竞争失败则进入EntryList等待。
  2. 释放锁时执行monitorexit，递减计数器直至0，唤醒EntryList中的线程。

三、锁升级策略（自适应优化）
JVM根据线程竞争动态调整锁状态，降低同步开销：

  1. 偏向锁（Biased Locking）

    • 适用场景：单线程重复获取锁。
    • 实现：通过CAS将线程ID写入Mark Word，后续无需同步操作。
    • 撤销：检测到其他线程竞争时（通过Epoch机制），升级为轻量级锁。

  2. 轻量级锁（Lightweight Locking）

    • 适用场景：低竞争、短临界区。
    • 实现：线程在栈帧中创建Lock Record，CAS将Mark Word复制到Lock Record并指向它。
    • 自旋失败：超过默认自旋次数（JDK6前固定10次，后改为自适应），升级为重量级锁。

  3. 重量级锁（Heavyweight Locking）

    • 实现：依赖操作系统的互斥量（Mutex）实现线程阻塞，通过Monitor的EntryList管理竞争线程。
    • 开销：涉及用户态到内核态的切换，性能损耗较高。

四、synchronized的字节码实现
通过monitorenter和monitorexit指令实现同步控制：

public void syncMethod() {
    synchronized(obj) {
        // 临界区代码 
    }
}

编译后的字节码：

0: aload_1              // 加载obj到操作数栈 
1: dup                  
2: astore_2             
3: monitorenter         // 尝试获取锁 
4: aload_2             
5: monitorexit          // 正常退出释放锁 
6: goto          14 
9: astore_3             
10: aload_2             
11: monitorexit         // 异常退出释放锁（确保锁释放）
12: aload_3             
13: athrow              
14: return
  • 异常处理表：保证无论代码块是否抛出异常，都会执行monitorexit。

五、JVM优化策略

  1. 锁粗化（Lock Coarsening）
    合并多个相邻同步块，减少锁获取/释放次数。

    // 优化前 
synchronized(obj) { ... }
synchronized(obj) { ... }
// 优化后 
synchronized(obj) { ...; ... }

  2. 锁消除（Lock Elimination）
    通过逃逸分析，移除不可能存在共享资源竞争的锁。

    public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer(); // 局部变量，无竞争 
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
}

  3. 自适应自旋（Adaptive Spinning）
    根据历史自旋成功率动态调整自旋次数，避免CPU空转。

六、性能影响与应用场景

  1. 低竞争场景：偏向锁和轻量级锁几乎无性能损耗。
  2. 高竞争场景：重量级锁的线程阻塞可能成为性能瓶颈（建议改用ReentrantLock或CAS）。
  3. 锁粒度控制：尽量缩小同步代码块范围，减少锁持有时间。

总结
synchronized通过对象头存储锁状态、Monitor实现互斥访问、锁升级策略平衡性能，成为Java线程安全的基石。其设计体现了JVM对“快速路径（Fast Path）”和“慢速路径（Slow Path）”的智能切换。开发中需结合竞争强度、临界区大小等因素，合理选择同步方案。

synchronized锁对象为class的时候锁信息储存在哪里？

当使用 synchronized 锁对象为 Class 时（例如 synchronized(MyClass.class) 或修饰静态方法），锁信息存储的位置与普通对象锁的存储机制一致，但其具体载体是 Class 类对应的 Java 对象头。

Monitor 机制

Monitor 机制是 synchronized 关键字实现线程同步的核心底层机制，其工作原理可分为以下几个关键点：

一、Monitor 的基本结构

  1. 对象关联性
    每个 Java 对象（包括类对象）在创建时都会关联一个 Monitor（监视器），用于管理线程对同步代码的访问。

  2. 核心组成部分

    • Owner（持有者）：当前持有锁的线程。
    • Entry Set（入口队列）：等待获取锁的线程队列。
    • Wait Set（等待队列）：通过 wait() 方法主动释放锁并进入阻塞状态的线程队列。

二、互斥访问的实现原理

  1. 锁的获取与释放

    • 当线程执行到 synchronized 代码块时，会尝试通过 CAS 操作获取对象的 Monitor。
    • 若 Monitor 的 Owner 为空，线程成为 Owner 并执行同步代码；否则，线程进入 Entry Set 等待。

  2. 重入性支持
    Monitor 通过计数器（_recursions）支持锁重入，同一线程多次获取锁时计数器递增，释放时递减至零才会完全释放锁。

三、线程协作机制（wait/notify）

  1. wait() 的运作
    线程调用 wait() 后，会释放锁并进入 Wait Set，等待其他线程通过 notify() 或 notifyAll() 唤醒。

  2. notify() 的触发
    唤醒 Wait Set 中的一个线程，该线程会从阻塞状态转移到 Entry Set，重新竞争锁。

object和锁相关的属性方法

与锁相关的核心机制通过 Object 类的方法和底层对象结构实现，主要涉及线程同步、锁状态管理及线程协作。以下是详细说明：

一、Object 类中与锁相关的核心方法

  1. wait() 系列方法

    • 作用：使当前线程释放锁并进入等待状态，直到其他线程调用 notify()/notifyAll() 或超时。
    • 重载方法：
      • wait()：无限等待。
      • wait(long timeout)：等待指定毫秒。
      • wait(long timeout, int nanos)：更高精度超时控制。
    • 使用条件：必须在同步代码块（synchronized）内调用，否则抛出 IllegalMonitorStateException。

  2. notify() 和 notifyAll()

    • notify()：随机唤醒一个等待该对象锁的线程，被唤醒的线程需重新竞争锁。
    • notifyAll()：唤醒所有等待该对象锁的线程。
    • 注意事项：同样必须在同步代码块内调用。
Java并发编程(三) : synchronized底层原理、优化Monitor重量级锁、轻量级锁、自旋锁(优化重量级锁竞争)、偏向锁
Guizy
01-02 3683
一、 Monitor 概念 1、 Java 对象头 对象头 对象头包含两部分：运行时元数据（Mark Word）和类型指针 (Klass Word) 运行时元数据 哈希值（HashCode），可以看作是堆中对象的地址 GC分代年龄（年龄计数器） 锁状态标志 线程持有的锁 偏向线程ID 偏向时间戳 类型指针 指向类元数据InstanceKlass，确定该对象所属的类型。指向的其实是方法区中存放的类元信息 说明：如果对象是数组，还需要记录数组的长度 以 32 位虚拟机为例,普通对象的对象头
Java同步锁Synchronized底层源码和原理剖析
赵广陆
05-24 872
目录1 synchronized场景回顾2 反汇编寻找锁实现原理3 synchronized虚拟机源码3.1 HotSpot源码Monitor生成3.2 HotSpot源码之Monitor竞争3.3 HotSpot源码之Monitor等待3.4 HotSpot源码之Monitor释放 1 synchronized场景回顾 目标： synchronized回顾（锁分类–>多线程） 概念 synchronized：是Java中的关键字，是一种同步锁。 Java中锁分为以下几种： 乐观锁、悲观锁(syn)
JAVA系列教程：Object Monitor与Synchronized关键字
marylgao技术专栏
03-10 1277
java Object Monitor机制 每个java对象都是一个monitor object，通过该monitor object, 可以实现线程之间的阻塞和唤醒 具体转换过程: 当线程需要获取Object Monitor的锁时，进入Entry Set 如果线程获取锁成功，则进入The Owner状态，每个Object的Ower同一时刻只能有一个线程进入 如果The Owner调用...
关于synchronized的Monitor Object机制的研究
m_xiaoer的博客
06-15 9803
这是一道面试题 Synchronized 介绍 monitor Object 设计模式 Monitor(java多线程同步机制) Refer synchronized介绍 synchronized关键字通过修饰一个方法或声明一个代码块，从而产生一个同步对象锁以及对应的同步代码块。 每当有线程要对该同步代码块进行访问时，线程就会首先尝试去获取该对象锁，并在成功获取到对象锁后，对该同步代码
Java~深度剖析synchronized与ObjectMonitor、volatile和内存屏障
q424042373的博客
05-23 1117
所以在对比lock锁和synchronize的锁的时候就会发现很多不同之处首先synchronize的是JVM实现的, 是一个关键字, 而lock是一个类, 是基于AQS实现的要从数据结构上说, 他俩真的差不多,都是维护着一个变量和CAS操作的队列, 但是JVM的更细节, 他为了提高出队速度, 将一个队分成了俩个队列, 分别为_WaitSet 和 _EntryList, lock只维护了一个, 至于那个变量键值一模一样, 都是表示现在上锁的次数。
锁 =》 Synchronized、锁升级过程、ObjectMonitor
weixin_40505750的博客
05-06 189
每个对象都具有一个ObjectMonitor与之关联， 在C++中的数据结构如下： ObjectMonitor() { _count = 0; //记录数 _recursions = 0; //锁的重入次数 _owner = NULL; //指向持有ObjectMonitor对象的线程 _WaitSet = NULL; //调用wait后，线程会被加入到_WaitSet _EntryList = NULL ; /...
线程安全问题--基于ObjectMonitor的同步机制
moyuerrr的博客
09-30 786
Thread-2 执行完同步代码块的内容，根据 obj 对象头中 Monitor 地址寻找，设置 Owner 为空，把线程栈的锁记录中的对象头的值设置回 MarkWord。synchronized 修饰的方法的不具备继承性，所以子类是线程不安全的，如果子类的方法也被 synchronized 修饰，两个锁对象其实是一把锁，而且是。批量撤销：当撤销偏向锁阈值超过 40 次后，JVM 会觉得自己确实偏向错了，根本就不该偏向，于是整个类的所有对象都会变为不可偏向的，新建的对象也是不可偏向的。
【Java并发知识总结 | 第五篇】深入理解Synchronized底层原理（Monitor对象、Synchronized锁优化）
踢桃的成长之路
03-26 2697
深入理解Synchronized底层原理（Monitor对象、Synchronized锁优化）
锁的分类和synchronized底层原理
w1lgy的博客
06-24 1083
文章目录一、JAVA中锁的概念1、自旋锁2、乐观锁3、悲观锁4、独享锁(写)5、共享锁(读)6、可重入锁、不可重入锁7、公平锁、非公平锁二、synchronized的底层原理1、 一、JAVA中锁的概念 1、自旋锁 是指当一个线程在获取锁的时候，如果锁已经被其它线程获取，那么该线程将循环等待，然后不断的判断锁是否能够被成功获取，直到获取到锁才会退出循环。 自旋锁有两种表现形式： 1、AtomicI......
【Java面试笔记：进阶】16.synchronized底层如何实现？什么是锁的升级、降级？
RickyIT的专栏
04-24 991
的底层实现通过Monitor对象和锁的升级、降级机制优化性能。现代JDK中的锁机制（偏斜锁、轻量级锁、重量级锁）适用于不同的竞争场景。Java 并发包提供了多种锁类型（如等），适用于不同的应用场景。理解锁的实现机制和优化策略，有助于开发高性能的并发程序。
java虚拟机锁的升级和比较
qq360828703的博客
07-21 1068
锁的升级和比较 无状态锁(01)–>偏心锁(10)–>轻量级锁(00)(自旋锁)–>重量级锁 偏心锁:即偏向于第一个获得该对象锁的线程,如果在这个线程获得偏向锁后,之后只要该锁没有被别的线获取,则持有该偏向锁的线程将永远不需要被同步 偏向锁的MarkWord中包含:线程ID、epoch、对象分代年龄、是否偏心锁(1)、锁标志位(01) 偏向锁的获得: 当锁对象第一次被获取时,如线程1访问同步快,
synchronized 的 monitor 机制
JellyfishMIX 的博客
04-11 1299
monitor 是 synchronized 中用以实现线程之间的互斥与协作的主要手段。每个 monitor 在每个时刻，只能被一个线程持有，该线程就是 activeThread，其它线程都是 waitingThread，分别在两个队列 entrySet 和 waitSet 里等候。在 entrySet 中等待的线程状态是 waiting for monitor entry，而在 wait set 中等待的线程状态是 in Object.wait()。
并发编程-synchronized的工作模式monitor
痞子的博客
02-06 259
并发编程之synchronized的工作模式monitor 一、ObjectMonitor原理图 二、原理解释 持有锁的线程发现条件不足，调用wait，即进入Waitset变为waiting状态 blocked和waiting的线程都处于阻塞状态，不占用cpu时间片 blocked的线程会在持有锁的线程释放锁时被唤醒 waiting线程会在持有锁的线程调用 notify或者notifyAll时唤醒，但唤醒后不意味着立刻获得锁，仍然需要进入EntryList重新竞争 ...
多线程(二) -- 管程(二) -- Synchronized底层Monitor，轻量级、偏向锁，锁膨胀
weixin_39724194的博客
01-06 1175
Java对象头 以 32 位虚拟机为例,普通对象的对象头结构如下，其中的Klass Word为指针，指向对应的Class对象； 数组对象： 其中 Mark Word 结构为： 所以一个对象的结构如下： Monitor（锁） Monitor被翻译为监视器或管程 每个java对象都可以关联一个monitor对象，如果使用synchronized给对象上锁（重量级）之后，该对象头的Mark Word中就被设置指向Monitor对象的指针 monitor结构如下： 刚开始时Monitor中的Owner为
synchronized 详解
GeGe&YoYo的博客
08-03 2695
synchronized 是什么？应该怎么使用？ synchronized底层之monitor、对象头、Mark Word synchronized的锁重入、锁消除、锁升级原理？无锁、偏向锁、轻量级锁、自旋、重量级锁，锁的升级过程 synchronized怎么保证可见性、有序性、原子性？ ...
JUC 十. synchronized深入
qq_29799655的博客
05-14 125
目录一. 基础复习简单解释对象头如何查看对象头二. 根据synchronized修饰不同成员了解synchronized实现原理同步代码块小总结同步方法小总结synchronized 与 管程底层分析三. 锁升级相关四. synchronized 可重入分析总结 一. 基础复习 synchronized,与 ReentrantLock 都属于悲观锁 乐观锁,例如Version,Atomic包下的原子类AtomicInteger 等,基于cas实现乐观锁 synchronized 根据编写方式不同分为: 同
synchronized底层monitor原理
qq_63815371的博客
01-09 1066
synchronized底层使用monitor来控制锁的活动。了解monitor中的各个属性值的含义，锁的竞争流程。
Java 锁机机制——浅析 Synchronized
IT小小鸟～～
07-23 9419
剖析 SynchronizedSynchronized 介绍Synchronized 方面的文章网上有很多了。它主要是用来进行同步操作。也被称为重量级的锁，它的同步包括： 对于普通方法同步，锁是当前实例对象 对于静态方法同步，锁是当前类的 Class 对象 对于方法块同步，锁是 Synchronized 括号里的对象 那么如何理解锁是“对象”。Java 编程语言中号称一切皆对象。当我们 new 一个
【JUC并发编程】synchronized原理分析（下）（ObjectMonitor 源码解读\ Hotspot源码解读\ synchronized底层实现原理总结\ 轻量锁、偏向锁、重量锁原理分析）
记录各种Bug解决案例及日常学习内容
05-05 1106
目录一、ObjectMonitor 源码解读1. 锁池2. 等待池3. wait与notify原理分析二、Hotspot源码解读1. synchronized底层实现原理总结2. 轻量锁原理分析3. 偏向锁原理分析3.1 偏向锁原理3.2 偏向锁撤销3.3 批量重偏向3.4 批量撤销4. 重量锁原理分析5. 锁粗化6. 锁消除7. JDK15 默认关闭偏向锁优化原因 一、ObjectMonitor 源码解读 Java底层使用 C++ hotspot虚拟机 http://hg.openjdk.java.net
✅synchronized锁的是什么？
最新发布
08-02
<think>我们正在讨论Java中synchronized关键字的锁定对象。根据引用[1]和引用[2]： - synchronized锁定的对象可以是实例对象或类对象（Class对象）。 - 当修饰实例方法时，锁定的是当前实例对象（this）。 - 当修饰静态方法时，锁定的是当前类的Class对象。 - 当修饰代码块时，可以指定锁定的对象（任意对象）。 因此，synchronized锁定的对象取决于使用方式： 1. 实例方法：锁定调用该方法的实例对象（this）。 2. 静态方法：锁定该类的Class对象（如MyClass.class）。 3. 代码块：锁定括号内指定的对象。 注意：每个对象都有一个与之关联的监视器锁（monitor），当线程进入synchronized代码块时，会尝试获取该对象的监视器锁，如果获取成功则执行代码，否则阻塞。 另外，引用[3]提到，在JVM中，对象的监视器锁由ObjectMonitor对象实现，它记录了锁的状态、持有锁的线程、等待队列等信息。 下面用代码示例说明： 示例1：实例方法锁 ```java public class Example { public synchronized void instanceMethod() { // 锁定的是当前实例对象，即this } } ``` 示例2：静态方法锁 ```java public class Example { public static synchronized void staticMethod() { // 锁定的是Example.class（Class对象） } } ``` 示例3：代码块锁 ```java public class Example { private final Object lock = new Object(); public void method() { synchronized (lock) { // 锁定的是lock对象 } } } ``` 重要规则： - 多个线程访问同一个对象的synchronized方法/代码块会互斥。 - 不同对象的synchronized方法/代码块不会互斥（因为锁对象不同）。 - 类锁和实例锁是不同的锁，因此不会互斥。 例如： 线程1：调用obj1的实例同步方法（锁定obj1） 线程2：调用obj2的实例同步方法（锁定obj2） -> 不会互斥，因为锁对象不同 线程3：调用类的静态同步方法（锁定类对象） -> 与上面两个都不互斥，因为锁对象不同 但是，如果多个线程同时访问同一个对象（或同一个类）的synchronized方法/代码块，则会发生互斥（阻塞等待）。 引用[1]提到：synchronized锁住的是一个对象或者类（类本身也是对象，即Class对象），而不是方法或者代码段。因此，锁的粒度是对象级别。 总结：synchronized锁定的对象取决于使用方式，具体为： - 实例方法：当前实例对象（this） - 静态方法：当前类的Class对象 - 代码块：显式指定的对象 这样，通过锁定不同的对象，可以实现不同粒度的同步控制。 相关问题： 1. 如何避免synchronized导致的死锁？ 2. synchronized锁升级过程是怎样的？ 3. 为什么说synchronized锁是非公平锁？</think>### Java中synchronized关键字的锁定对象详解 #### 一、锁定对象的本质 synchronized锁定的**不是方法或代码段**，而是**对象或类**（本质也是对象）。根据使用方式不同，锁定对象分为两类： 1. **实例对象锁**：锁定具体对象实例 2. **类对象锁**：锁定类的Class对象（如`MyClass.class`） #### 二、不同使用场景的锁定对象 | 使用方式 | 锁定对象 | 示例代码 | |------------------------------|--------------------------|--------------------------------------------------------------------------| | **修饰实例方法** | 当前实例对象 (`this`) | `public synchronized void method() {...}` [^1] | | **修饰静态方法** | 类的Class对象 | `public static synchronized void staticMethod() {...}` | | **代码块指定实例对象** | 显式指定的对象实例 | `synchronized(obj) {...}` | | **代码块指定Class对象** | 类的Class对象 | `synchronized(MyClass.class) {...}` | #### 三、锁互斥规则 1. **相同对象锁互斥**： ```java // 线程1和线程2访问同一个对象的同步方法会互斥 MyObject obj = new MyObject(); new Thread(obj::syncMethod).start(); // 线程1 new Thread(obj::syncMethod).start(); // 线程2 ❌ 阻塞 ``` 2. **不同对象锁不互斥**： ```java // 线程1和线程2访问不同对象的同步方法不互斥 MyObject obj1 = new MyObject(); MyObject obj2 = new MyObject(); new Thread(obj1::syncMethod).start(); // 线程1 new Thread(obj2::syncMethod).start(); // 线程2 ✅ 并行执行 ``` 3. **类锁与实例锁不互斥**： ```java class MyClass { public synchronized void instanceMethod() {...} // 实例锁 public static synchronized void staticMethod() {...} // 类锁 } // 可同时执行（锁对象不同） new Thread(() -> new MyClass().instanceMethod()).start(); new Thread(MyClass::staticMethod).start(); // ✅ 并行执行 ``` #### 四、底层实现原理 在JVM中，每个对象关联一个**监视器锁（Monitor）**，由`ObjectMonitor`实现（C++）： ```cpp ObjectMonitor() { _count = 0; // 锁获取次数 _owner = NULL; // 持有锁的线程 _EntryList = NULL; // 阻塞线程队列 _WaitSet = NULL; // 调用wait()的线程队列 } ``` 当线程执行`synchronized`代码时： 1. 通过`monitorenter`指令尝试获取对象的监视器 2. 若`_owner`为null，则获得锁并设置`_owner`为当前线程 3. 若已被占用，则进入`_EntryList`阻塞等待[^3] #### 五、关键特性 1. **可重入性**：同一线程可重复获取同一把锁 ```java public synchronized void methodA() { methodB(); // ✅ 可重入 } public synchronized void methodB() {...} ``` 2. **锁粒度控制**： - 细粒度锁：锁定独立对象减少竞争 ```java private final Object lock1 = new Object(); private final Object lock2 = new Object(); void method() { synchronized(lock1) { /* 操作资源1 */ } synchronized(lock2) { /* 操作资源2 */ } } ``` 3. **锁释放保证**： - 正常执行：通过`monitorexit`释放 - 异常退出：JVM确保锁释放（通过异常处理表） #### 六、使用建议 1. **避免锁字符串常量**：字符串常量池可能引发意外锁竞争 ```java // 危险操作（不同模块可能意外共享锁） synchronized("GLOBAL_LOCK") {...} ``` 2. **优先选择私有锁对象**： ```java private final Object myLock = new Object(); // ✅ 安全 ``` 3. **类锁使用场景**： - 静态数据保护 - 类级别操作（如加载资源） > **关键原则**：锁的互斥范围取决于**锁对象的唯一性**，而非代码位置[^2]。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值