JAVA中synchronized重量级锁加锁和释放锁的机制

一、重量级锁的核心：Monitor 对象‌

当锁升级为重量级锁时，对象的 Mark Word 会指向一个 ‌Monitor 对象‌（由 C++ 的 ObjectMonitor 实现）。该对象管理锁的竞争和线程调度。

‌ObjectMonitor 关键字段‌

class ObjectMonitor {
    void*     _header;       // 原始对象的 Mark Word
    void*     _owner;        // 持有锁的线程
    intptr_t  _recursions;   // 锁重入次数（可重入锁的关键）
    WaitSet   _WaitSet;      // 调用 wait() 的线程队列（等待条件变量）
    EntryList _EntryList;    // 竞争锁失败的线程队列（阻塞状态）
    // ...
};

---

‌二、加锁机制（Locking）‌

当线程尝试获取重量级锁时，流程如下：

‌1. 快速路径（Fast Path）‌

• ‌锁未被占用‌（_owner == NULL）：
  线程通过 ‌CAS 操作‌ 将 _owner 设置为当前线程，并更新 _recursions=1，直接获取锁。

‌2. 锁已被占用‌

• ‌锁被当前线程重复获取‌（可重入性）：
  _recursions 递增 1，无需竞争。
• ‌锁被其他线程占用‌：
  线程进入 _EntryList 队列，并调用操作系统 ‌pthread_mutex_lock‌ 进入阻塞状态（通过内核态调度），直到被唤醒。

‌3. 内核态阻塞‌

• ‌系统调用‌：通过操作系统的 ‌互斥量（Mutex）‌ 和 ‌条件变量（Condition Variable）‌ 实现线程阻塞。
• ‌性能代价‌：用户态到内核态的切换、上下文切换、线程调度延迟。

---

‌三、释放锁机制（Unlocking）‌

释放锁时，需处理锁状态和线程唤醒：

‌1. 重入锁释放‌

• ‌减少重入计数‌：_recursions--，若 _recursions > 0，直接返回（锁未完全释放）。

‌2. 完全释放锁‌

• ‌清除 _owner‌：将 _owner 设置为 NULL。
• ‌唤醒阻塞线程‌：
  • ‌策略‌：默认采用 ‌非公平策略‌，直接从 _EntryList 或 _WaitSet 中唤醒一个线程。
  • ‌操作‌：调用操作系统 ‌pthread_mutex_unlock‌ 释放互斥量，并通过 ‌pthread_cond_signal‌ 通知等待线程。

‌3. 线程唤醒‌

• ‌从 EntryList 获取线程‌：被唤醒的线程重新竞争锁。
• ‌锁传递‌：若采用 ‌公平锁模式‌（通过 synchronized 无法配置，需用 ReentrantLock），按队列顺序唤醒线程。

---

‌四、流程图解‌

‌加锁流程‌

线程尝试获取锁 → 
    if (锁未被占用):
        CAS 设置 _owner 为当前线程 → 成功获取锁
    else if (锁属于当前线程):
        _recursions++ → 重入成功
    else:
        进入 _EntryList → 阻塞（内核态）

‌释放流程‌

线程释放锁 →
    _recursions-- → 
    if (_recursions == 0):
        设置 _owner = NULL →
        唤醒 _EntryList/_WaitSet 中的线程（内核态）

---

‌五、性能影响与优化‌

‌1. 性能问题‌

• ‌上下文切换‌：线程阻塞和唤醒涉及内核态操作，耗时约 ‌微秒级‌。
• ‌竞争激烈场景‌：频繁的重量级锁操作会导致吞吐量骤降。

‌2. 优化建议‌

• ‌减少同步块粒度‌：缩小 synchronized 代码块范围。
• ‌替换并发工具‌：使用 ReentrantLock（可配置公平性）、StampedLock 或 CAS 操作。
• ‌避免锁竞争‌：通过无锁数据结构（如 ConcurrentHashMap）或线程本地存储（ThreadLocal）。

---

‌六、示例代码与底层验证‌

‌1. 代码示例（触发重量级锁）‌

public class HeavyLockDemo {
    private static final Object lock = new Object();
    private static int counter = 0;

    public static void main(String[] args) {
        // 多线程竞争锁
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (lock) {
                    counter++; // 竞争激烈时，锁升级为重量级锁
                }
            }).start();
        }
    }
}

‌2. 查看 Monitor 状态‌

• ‌JVM 参数‌：

  -XX:+PrintAssembly          # 查看汇编代码（需 hsdis 库）
  -XX:+PrintSafepointStatistics # 输出安全点信息
  

• ‌工具‌：使用 ‌jstack‌ 或 ‌Java Mission Control‌ 观察线程的阻塞状态（BLOCKED）。

---

‌总结‌

• ‌重量级锁的核心‌：通过 Monitor 对象和操作系统互斥量管理线程阻塞与唤醒。
• ‌可重入性‌：通过 _recursions 字段实现锁的重复获取。
• ‌设计权衡‌：在保证线程安全的前提下，牺牲部分性能以处理高竞争场景。
• ‌优化方向‌：减少锁竞争、缩小同步范围、替换更高效的并发工具。