synchronized全面解析 ⭐⭐⭐

public class Counter {
 
    // 共享变量
    private int count = 0;
 
    // synchronized 修饰实例方法，锁对象 = this（即调用该方法的 Counter 实例）
    public synchronized void increment() {
        // 进入方法时，JVM 自动对 this 执行 monitorenter
        count++;  // 临界区：同一时刻只有持有 this 锁的线程能执行
        // 方法返回时，JVM 自动对 this 执行 monitorexit
    }
 
    // 同一个实例的另一个 synchronized 方法，锁对象也是 this
    // 因此与 increment() 互斥 —— 线程 A 在执行 increment() 时，线程 B 无法进入 getCount()
    public synchronized int getCount() {
        return count;  // 读操作同样被保护，保证可见性
    }
}

public class LockThisDemo {
 
    public static void main(String[] args) {
        // ========== 场景一：同一个对象 —— 互斥 ==========
        Counter sameCounter = new Counter();
 
        // 线程 A 和线程 B 操作的是同一个 sameCounter 实例
        // 它们竞争的是同一把锁（sameCounter 对象的 Monitor）
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                sameCounter.increment();  // 锁对象 = sameCounter
            }
        });
 
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                sameCounter.increment();  // 锁对象 = sameCounter（同一把锁，互斥）
            }
        });
 
        t1.start();
        t2.start();
 
        // 最终结果一定是 20000 —— 线程安全
 
        // ========== 场景二：不同对象 —— 不互斥 ==========
        Counter counterA = new Counter();  // 实例 A
        Counter counterB = new Counter();  // 实例 B
 
        // 线程 A 锁的是 counterA，线程 B 锁的是 counterB
        // 两把不同的锁，完全不互斥
        Thread t3 = new Thread(() -> counterA.increment());  // 锁对象 = counterA
        Thread t4 = new Thread(() -> counterB.increment());  // 锁对象 = counterB
        // t3 和 t4 可以同时执行，互不阻塞
    }
}

// 场景一：同一实例 —— 同一把锁
//
//  Thread-A ──┐
//             ├──▶ [ sameCounter 对象 ] ──▶ Monitor(锁)
//  Thread-B ──┘         ↑
//                    竞争同一把锁，互斥
//
//
// 场景二：不同实例 —— 不同锁
//
//  Thread-A ────▶ [ counterA 对象 ] ──▶ Monitor-A(锁)
//
//  Thread-B ────▶ [ counterB 对象 ] ──▶ Monitor-B(锁)
//                    各自有各自的锁，互不干扰

public class GlobalCounter {
 
    // 静态共享变量
    private static int count = 0;
 
    // synchronized 修饰静态方法
    // 锁对象 = GlobalCounter.class（Class 对象，全局唯一）
    public static synchronized void increment() {
        // 无论通过哪个实例调用，还是直接 GlobalCounter.increment()
        // 竞争的都是同一把锁：GlobalCounter.class
        count++;
    }
 
    // 同样是静态 synchronized 方法，与 increment() 共享同一把 Class 锁
    public static synchronized int getCount() {
        return count;
    }
}

public class LockClassDemo {
 
    public static void main(String[] args) {
        // 即使创建了两个不同的实例
        GlobalCounter obj1 = new GlobalCounter();
        GlobalCounter obj2 = new GlobalCounter();
 
        // 通过不同实例调用静态 synchronized 方法
        // 本质上锁的都是 GlobalCounter.class，所以依然互斥
        Thread t1 = new Thread(() -> obj1.increment());  // 锁 = GlobalCounter.class
        Thread t2 = new Thread(() -> obj2.increment());  // 锁 = GlobalCounter.class（同一把）
 
        // 直接通过类名调用也是同一把锁
        Thread t3 = new Thread(() -> GlobalCounter.increment());  // 锁 = GlobalCounter.class
 
        // t1, t2, t3 三者互斥，同一时刻只有一个能执行
    }
}

public class MixedLockDemo {
 
    private int instanceVar = 0;
    private static int staticVar = 0;
 
    // 实例方法 —— 锁 this
    public synchronized void instanceMethod() {
        instanceVar++;
        // 持有的是 this 对象的 Monitor
    }
 
    // 静态方法 —— 锁 Class
    public static synchronized void staticMethod() {
        staticVar++;
        // 持有的是 MixedLockDemo.class 的 Monitor
    }
 
    public static void main(String[] args) {
        MixedLockDemo obj = new MixedLockDemo();
 
        // 线程 A 调用实例方法，拿的是 obj 的锁
        Thread t1 = new Thread(() -> obj.instanceMethod());
 
        // 线程 B 调用静态方法，拿的是 MixedLockDemo.class 的锁
        Thread t2 = new Thread(() -> MixedLockDemo.staticMethod());
 
        // t1 和 t2 可以同时执行！因为它们锁的是不同对象
        // this 锁 ≠ Class 锁
        t1.start();
        t2.start();
    }
}

synchronized (lockObject) {
    // 临界区代码
    // 只有获取到 lockObject 的 Monitor 的线程才能进入
}

public class SyncBlockDemo {
 
    // 专用锁对象 —— 推荐做法
    // 使用 final 防止锁对象引用被修改（如果引用变了，线程锁的就不是同一个对象了）
    private final Object lock = new Object();
 
    private int count = 0;
    private String name = "";
 
    // ========== 用法一：锁 this ==========
    // 等价于 synchronized 修饰实例方法
    public void incrementV1() {
        synchronized (this) {
            // 锁对象 = this，与 synchronized 实例方法效果完全相同
            count++;
        }
    }
 
    // ========== 用法二：锁 Class 对象 ==========
    // 等价于 synchronized 修饰静态方法
    public void incrementV2() {
        synchronized (SyncBlockDemo.class) {
            // 锁对象 = SyncBlockDemo.class，全局唯一
            count++;
        }
    }
 
    // ========== 用法三：锁自定义对象（推荐）==========
    public void incrementV3() {
        synchronized (lock) {
            // 锁对象 = lock，一个专门用于同步的私有对象
            count++;
        }
    }
}

public class FineGrainedLockDemo {
 
    private final Object lock = new Object();
    private int count = 0;
 
    // ❌ 粗粒度：整个方法都被锁住
    // 假设 someHeavyComputation() 耗时 500ms 且不涉及共享变量
    // 其他线程必须白白等待这 500ms
    public synchronized void coarseGrained() {
        someHeavyComputation();  // 不需要同步的耗时操作
        count++;                 // 真正需要同步的只有这一行
        someHeavyComputation();  // 又一个不需要同步的耗时操作
    }
 
    // ✅ 细粒度：只锁必要的部分
    // 其他线程只需要等待 count++ 的极短时间
    public void fineGrained() {
        someHeavyComputation();  // 不加锁，多线程可以并行执行
        synchronized (lock) {
            count++;             // 只对临界区加锁
        }
        someHeavyComputation();  // 不加锁，多线程可以并行执行
    }
 
    private void someHeavyComputation() {
        // 模拟耗时操作（如网络IO、复杂计算等）
    }
}

public class MultiLockDemo {
 
    // 两个独立的锁对象，分别保护不同的共享资源
    private final Object balanceLock = new Object();  // 保护余额
    private final Object orderLock = new Object();    // 保护订单
 
    private double balance = 0.0;
    private int orderCount = 0;
 
    // 操作余额时，只锁 balanceLock
    public void updateBalance(double amount) {
        synchronized (balanceLock) {
            // 线程操作余额时，不影响其他线程操作订单
            balance += amount;
        }
    }
 
    // 操作订单时，只锁 orderLock
    public void addOrder() {
        synchronized (orderLock) {
            // 线程操作订单时，不影响其他线程操作余额
            orderCount++;
        }
    }
 
    // 如果用 synchronized 修饰方法（锁 this），两个操作就会互斥
    // 明明操作的是不同资源，却要排队等待 —— 不必要的性能损失
}

// 多锁并发模型：
//
//  Thread-A ──▶ synchronized(balanceLock) ──▶ 操作 balance
//                                                              ← 互不干扰，可并行
//  Thread-B ──▶ synchronized(orderLock)   ──▶ 操作 orderCount
//
//
// 如果都用 synchronized 方法（锁 this）：
//
//  Thread-A ──▶ synchronized(this) ──▶ 操作 balance
//                    ↑ 同一把锁，必须排队
//  Thread-B ──▶ synchronized(this) ──▶ 操作 orderCount（被阻塞）

public class LockObjectBestPractice {
 
    // ✅ 推荐：使用 private final 的专用锁对象
    // private：外部无法获取锁对象，避免外部代码意外地对同一个对象加锁导致死锁
    // final：防止锁对象引用被重新赋值（一旦引用变了，线程就不再竞争同一把锁）
    private final Object lock = new Object();
 
    // ❌ 不推荐：锁 this —— 因为 this 引用是公开的，外部可以 synchronized(yourObj)
    // 这会导致你无法控制谁在跟你竞争同一把锁
 
    // ❌ 危险：锁 String 常量
    private final String strLock = "LOCK";
    // 由于字符串常量池（String Pool），不同类中值相同的字符串字面量
    // 实际上是同一个对象，可能导致毫不相关的代码互相阻塞
 
    // ❌ 危险：锁 Integer 等包装类型
    private final Integer intLock = 127;
    // Integer 在 -128~127 范围内有缓存（IntegerCache）
    // 不同地方的 Integer.valueOf(127) 返回的是同一个对象
 
    // ❌ 危险：锁 Boolean
    private final Boolean boolLock = true;
    // Boolean 只有 TRUE 和 FALSE 两个缓存实例
    // 整个 JVM 中所有 Boolean.TRUE 都是同一个对象
}

public class Quiz {
    public synchronized void methodA() {
        // 执行耗时操作...
    }
 
    public static synchronized void methodB() {
        // 执行耗时操作...
    }
 
    public static void main(String[] args) {
        Quiz obj = new Quiz();
        Thread t1 = new Thread(() -> obj.methodA());
        Thread t2 = new Thread(() -> Quiz.methodB());
        t1.start();
        t2.start();
    }
}

public class ReentrantDemo {
 
    // 第一个同步方法，锁对象是 this
    public synchronized void methodA() {
        System.out.println(Thread.currentThread().getName() + " 进入 methodA");
        // 在持有 this 锁的情况下，调用同样需要 this 锁的 methodB
        // 如果 synchronized 不可重入，这里将永远阻塞 —— 死锁！
        methodB();
    }
 
    // 第二个同步方法，锁对象同样是 this
    public synchronized void methodB() {
        System.out.println(Thread.currentThread().getName() + " 进入 methodB");
    }
 
    public static void main(String[] args) {
        ReentrantDemo demo = new ReentrantDemo();
        // 启动一个线程调用 methodA
        new Thread(demo::methodA, "Thread-1").start();
    }
}

// 时间线：
// T1 -> methodA()  : 获取 this 锁, count = 1
//   T1 -> methodB(): 重入 this 锁, count = 2
//   T1 <- methodB(): 退出, count = 1
// T1 <- methodA()  : 退出, count = 0, 锁真正释放

public class ParentClass {
 
    // 父类同步方法，锁对象是 this（即调用者实例）
    public synchronized void doSomething() {
        System.out.println("ParentClass.doSomething() - " 
            + Thread.currentThread().getName());
    }
}
 
public class ChildClass extends ParentClass {
 
    // 子类重写的同步方法，锁对象同样是 this
    @Override
    public synchronized void doSomething() {
        System.out.println("ChildClass.doSomething() - " 
            + Thread.currentThread().getName());
        // 调用父类的同步方法
        // this 是同一个对象，所以这是一次锁重入
        super.doSomething();
    }
 
    public static void main(String[] args) {
        ChildClass child = new ChildClass();
        // child 这个实例就是 this，贯穿子类和父类方法
        new Thread(child::doSomething, "Thread-1").start();
    }
}

public class RecursiveSync {
 
    private int count = 0; // 业务计数器
 
    // 递归同步方法，每次递归都重入 this 锁
    public synchronized void recursiveCall(int depth) {
        // 递归终止条件
        if (depth <= 0) {
            System.out.println("递归到底，count = " + count);
            return;
        }
        count++;                        // 修改共享状态
        System.out.println("depth=" + depth + ", count=" + count);
        recursiveCall(depth - 1);       // 递归调用，再次重入 this 锁
    }
 
    public static void main(String[] args) {
        RecursiveSync obj = new RecursiveSync();
        new Thread(() -> obj.recursiveCall(3), "T1").start();
    }
}

// HotSpot ObjectMonitor 简化伪代码 (C++)
// 源码位置: src/hotspot/share/runtime/objectMonitor.hpp
 
class ObjectMonitor {
    Thread* _owner;       // 当前持有锁的线程
    int     _recursions;  // 重入计数器
    // ... 省略 EntryList, WaitSet 等字段
}
 
// 加锁逻辑 (简化)
void ObjectMonitor::enter(Thread* current) {
    if (_owner == NULL) {
        // 锁空闲，直接获取
        _owner = current;       // 设置持有者
        _recursions = 1;        // 计数器置 1
    } else if (_owner == current) {
        // 同一线程再次进入 —— 可重入
        _recursions++;          // 计数器 +1，不阻塞
    } else {
        // 其他线程持有，当前线程进入 EntryList 阻塞
        enqueue_to_entry_list(current);
        block(current);
    }
}
 
// 解锁逻辑 (简化)
void ObjectMonitor::exit(Thread* current) {
    _recursions--;              // 计数器 -1
    if (_recursions == 0) {
        _owner = NULL;          // 计数器归零，真正释放锁
        wake_up_next_thread();  // 唤醒 EntryList 中等待的线程
    }
    // 如果 _recursions > 0，说明还在外层同步块中，不释放
}

public class SynchronizedNonInterruptible {
 
    // 共享锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程 A：先获取锁，然后长时间持有不释放
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程 A 已获取锁，将持有 10 秒...");
                try {
                    Thread.sleep(10_000);  // 模拟长时间持有锁
                } catch (InterruptedException e) {
                    // sleep 可以响应中断，但这里中断的是 A 自己
                    e.printStackTrace();
                }
            }
        }, "Thread-A");
 
        // 线程 B：尝试获取同一把锁，会被阻塞
        Thread threadB = new Thread(() -> {
            System.out.println("线程 B 尝试获取锁...");
 
            // 关键点：线程 B 在这里进入 BLOCKED 状态
            // 即使被 interrupt()，也不会从这里醒来
            synchronized (lock) {
                // 只有成功获取锁后，才会执行到这里
                System.out.println("线程 B 终于获取到锁！");
                // 此时检查中断标志，发现已经被设置为 true
                System.out.println("线程 B 的中断标志: " 
                    + Thread.currentThread().isInterrupted());
            }
        }, "Thread-B");
 
        threadA.start();
        Thread.sleep(500);  // 确保 A 先拿到锁
 
        threadB.start();
        Thread.sleep(500);  // 确保 B 已经开始等待锁
 
        // 打印 B 的状态：应该是 BLOCKED
        System.out.println("线程 B 的状态: " + threadB.getState());
 
        // 尝试中断线程 B
        System.out.println("主线程对线程 B 调用 interrupt()...");
        threadB.interrupt();
 
        // 中断后再看 B 的状态：仍然是 BLOCKED！
        Thread.sleep(500);
        System.out.println("中断后，线程 B 的状态: " + threadB.getState());
        System.out.println("线程 B 仍在阻塞等待锁，interrupt() 没有任何效果！");
    }
}

import java.util.concurrent.locks.ReentrantLock;
 
public class InterruptibleLockDemo {
 
    // 使用 ReentrantLock 替代 synchronized
    private static final ReentrantLock lock = new ReentrantLock();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程 A：获取锁并长时间持有
        Thread threadA = new Thread(() -> {
            lock.lock();  // 获取锁
            try {
                System.out.println("线程 A 已获取锁，将持有 10 秒...");
                Thread.sleep(10_000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();  // 必须在 finally 中释放锁
            }
        }, "Thread-A");
 
        // 线程 B：使用 lockInterruptibly() 可中断地等待锁
        Thread threadB = new Thread(() -> {
            System.out.println("线程 B 尝试可中断地获取锁...");
            try {
                // 关键区别：lockInterruptibly() 在等待时可以响应中断
                lock.lockInterruptibly();
                try {
                    System.out.println("线程 B 获取到锁");
                } finally {
                    lock.unlock();
                }
            } catch (InterruptedException e) {
                // 等待锁的过程中被中断，会抛出此异常
                System.out.println("线程 B 在等待锁时被中断，已放弃获取锁！");
            }
        }, "Thread-B");
 
        threadA.start();
        Thread.sleep(500);
 
        threadB.start();
        Thread.sleep(500);
 
        // 中断线程 B —— 这次会生效！
        System.out.println("主线程对线程 B 调用 interrupt()...");
        threadB.interrupt();
    }
}

Object lock = new Object();
 
Thread t1 = new Thread(() -> {
    synchronized (lock) {
        try { Thread.sleep(5000); } catch (InterruptedException e) {}
    }
});
 
Thread t2 = new Thread(() -> {
    synchronized (lock) {
        System.out.println("T2 中断标志: " + Thread.currentThread().isInterrupted());
    }
});
 
t1.start();
Thread.sleep(200);
t2.start();
Thread.sleep(200);
t2.interrupt();

// 管程的伪代码模型
monitor BoundedBuffer {
    // ---- 共享变量 ----
    Object[] buffer = new Object[N];  // 有界缓冲区
    int count = 0;                     // 当前元素数量
 
    // ---- 条件变量 ----
    condition notFull;   // 缓冲区未满的条件
    condition notEmpty;  // 缓冲区非空的条件
 
    // ---- 入口过程（同一时刻只有一个线程能执行）----
    void put(Object item) {
        while (count == N)        // 如果缓冲区满了
            wait(notFull);        // 在 notFull 条件上等待
        buffer[count++] = item;   // 放入元素
        signal(notEmpty);         // 通知：缓冲区非空了
    }
 
    Object take() {
        while (count == 0)        // 如果缓冲区空了
            wait(notEmpty);       // 在 notEmpty 条件上等待
        Object item = buffer[--count]; // 取出元素
        signal(notFull);          // 通知：缓冲区未满了
        return item;
    }
}

// Mark Word 在 64 位 JVM 中的布局（重量级锁状态）
// |---------------------------------------------------------------|-------|
// |                 指向 ObjectMonitor 的指针 (62 bits)              | 10   |
// |---------------------------------------------------------------|-------|
//                                                            锁标志位 = 10 表示重量级锁

// ObjectMonitor 核心结构（简化自 HotSpot C++ 源码）
// 路径: src/hotspot/share/runtime/objectMonitor.hpp
ObjectMonitor {
    _header;       // Mark Word 的备份，锁释放时需要还原
    _object;       // 指向持有该 Monitor 的 Java 对象
    _owner;        // 当前持有锁的线程（Owner）
    _recursions;   // 重入计数器，同一线程每重入一次 +1
    _count;        // 记录曾经等待过的线程总数（统计用）
    _WaitSet;      // 调用了 wait() 的线程集合（双向链表）
    _EntryList;    // 等待获取锁的线程集合（双向链表）
    _cxq;          // 竞争队列（Contention Queue），新来的竞争者先到这里
    _succ;         // 假定继承者（Heir Presumptive），优化唤醒用
}

// 线程尝试获取 Monitor 的伪代码流程
void enter(ObjectMonitor monitor) {
    // 第一步：尝试通过 CAS 将 _owner 从 null 设为当前线程
    if (CAS(&monitor._owner, null, currentThread)) {
        // CAS 成功，直接获取锁，进入临界区
        return;
    }
 
    // 第二步：CAS 失败，说明锁已被占用
    // 先进行一轮自旋（Adaptive Spinning），尝试避免阻塞
    for (int i = 0; i < spinCount; i++) {
        if (CAS(&monitor._owner, null, currentThread)) {
            return;  // 自旋期间锁被释放了，幸运地获取到
        }
    }
 
    // 第三步：自旋失败，将当前线程封装为 ObjectWaiter 节点
    ObjectWaiter node = new ObjectWaiter(currentThread);
 
    // 第四步：通过 CAS 将节点插入 _cxq 队列头部
    do {
        node.next = monitor._cxq;
    } while (!CAS(&monitor._cxq, node.next, node));
 
    // 第五步：调用 park() 挂起当前线程（进入 BLOCKED 状态）
    // 线程在此处阻塞，直到被 unpark() 唤醒
    park(currentThread);
 
    // 被唤醒后，重新尝试获取锁...
}

// 锁释放时的唤醒逻辑伪代码
void exit(ObjectMonitor monitor) {
    // 将 _owner 置为 null，释放锁
    monitor._owner = null;
 
    // 如果 _EntryList 不为空，从中取一个线程唤醒
    if (monitor._EntryList != null) {
        ObjectWaiter thread = monitor._EntryList.head;  // 取头部线程
        unpark(thread);  // 唤醒它，让它去竞争锁
        return;
    }
 
    // 如果 _EntryList 为空，检查 _cxq
    if (monitor._cxq != null) {
        // 将 _cxq 中的线程转移到 _EntryList
        moveToEntryList(monitor._cxq, monitor._EntryList);
        ObjectWaiter thread = monitor._EntryList.head;
        unpark(thread);  // 唤醒
    }
}

// Object.wait() 底层执行流程伪代码
void ObjectMonitor::wait(long timeout) {
    // 前置检查：当前线程必须是 Owner，否则抛出 IllegalMonitorStateException
    if (_owner != currentThread) {
        throw new IllegalMonitorStateException();
    }
 
    // 第一步：将当前线程封装为 ObjectWaiter 节点
    ObjectWaiter node = new ObjectWaiter(currentThread);
 
    // 第二步：将节点加入 _WaitSet（双向循环链表）
    addToWaitSet(node);
 
    // 第三步：释放锁（关键！）
    int savedRecursions = _recursions;  // 保存重入次数
    _recursions = 0;                    // 重入计数归零
    _owner = null;                      // 释放 Owner
 
    // 第四步：唤醒 _EntryList 中等待锁的线程
    // （因为锁已经释放了，应该让别人有机会获取）
    exit();
 
    // 第五步：挂起当前线程
    if (timeout == 0) {
        park(currentThread);            // 无限等待
    } else {
        parkWithTimeout(currentThread, timeout);  // 超时等待
    }
 
    // ---- 线程在此处阻塞，直到被 notify/notifyAll 唤醒 ----
 
    // 第六步：被唤醒后，重新竞争锁
    enter(this);  // 重新走获取锁的流程
 
    // 第七步：恢复重入计数
    _recursions = savedRecursions;
 
    // 此时线程重新成为 Owner，从 wait() 方法返回
}

// notify() 的底层逻辑
void ObjectMonitor::notify() {
    // 从 _WaitSet 中取出一个线程（通常是头部）
    ObjectWaiter node = dequeueFromWaitSet();
    if (node == null) return;  // WaitSet 为空，什么都不做
 
    // 将该线程移动到 _EntryList（或 _cxq）
    // 注意：不是直接唤醒！只是换了个队列
    addToEntryList(node);
}
 
// notifyAll() 的底层逻辑
void ObjectMonitor::notifyAll() {
    // 将 _WaitSet 中的所有线程逐个移动到 _EntryList
    while (_WaitSet != null) {
        ObjectWaiter node = dequeueFromWaitSet();
        addToEntryList(node);
    }
}

// 获取锁时的重入判断
void enter(ObjectMonitor monitor) {
    Thread current = Thread.currentThread();
 
    // 情况一：锁空闲，直接获取
    if (CAS(&monitor._owner, null, current)) {
        monitor._recursions = 1;  // 首次获取，重入计数 = 1
        return;
    }
 
    // 情况二：当前线程就是 Owner（重入）
    if (monitor._owner == current) {
        monitor._recursions++;    // 重入计数 +1，无需 CAS
        return;
    }
 
    // 情况三：其他线程持有锁，进入阻塞流程
    // ... 进入 _cxq -> _EntryList -> park()
}
 
// 释放锁时的重入处理
void exit(ObjectMonitor monitor) {
    monitor._recursions--;        // 重入计数 -1
 
    if (monitor._recursions > 0) {
        return;  // 还有外层 synchronized 未退出，不真正释放锁
    }
 
    // _recursions == 0，真正释放锁
    monitor._owner = null;
    // 唤醒 _EntryList 中的等待线程...
}

public class MonitorDemo {
    // 这个对象就是管程，它的 ObjectMonitor 管理所有同步状态
    private final Object lock = new Object();
    // 共享变量（管程保护的数据）
    private boolean dataReady = false;
 
    // 生产者线程
    public void producer() {
        synchronized (lock) {
            // 此时当前线程成为 _owner，_recursions = 1
            System.out.println(Thread.currentThread().getName() + " 获取锁，开始生产数据...");
 
            // 模拟耗时操作
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
 
            // 修改共享变量
            dataReady = true;
 
            // 调用 notify()：将 _WaitSet 中的一个线程移到 _EntryList
            // 注意：此时并不会立即释放锁，被通知的线程还要等
            lock.notify();
            System.out.println(Thread.currentThread().getName() + " 已通知消费者，但锁还没释放");
 
            // 这里可以继续执行其他操作，锁仍然被当前线程持有
            System.out.println(Thread.currentThread().getName() + " 继续持有锁做其他事情...");
        }
        // 退出 synchronized 块 -> monitorexit -> _owner = null -> 唤醒 _EntryList 中的线程
        System.out.println(Thread.currentThread().getName() + " 释放了锁");
    }
 
    // 消费者线程
    public void consumer() {
        synchronized (lock) {
            // 获取锁成为 _owner
            System.out.println(Thread.currentThread().getName() + " 获取锁，检查数据是否就绪...");
 
            // 经典的 wait 范式：必须用 while 循环检查条件，防止虚假唤醒（spurious wakeup）
            while (!dataReady) {
                try {
                    System.out.println(Thread.currentThread().getName() + " 数据未就绪，调用 wait() 释放锁并等待");
                    // wait() 执行过程：
                    // 1. 保存 _recursions
                    // 2. _owner = null（释放锁）
                    // 3. 当前线程加入 _WaitSet
                    // 4. park() 挂起线程
                    lock.wait();
                    // 被唤醒后执行过程：
                    // 1. 从 _WaitSet 移到 _EntryList
                    // 2. 重新竞争锁（enter）
                    // 3. 获取锁后恢复 _recursions
                    // 4. 从 wait() 返回，继续执行
                    System.out.println(Thread.currentThread().getName() + " 被唤醒，重新获取到锁，再次检查条件");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
 
            // 条件满足，处理数据
            System.out.println(Thread.currentThread().getName() + " 数据已就绪，开始消费！");
        }
    }
 
    public static void main(String[] args) {
        MonitorDemo demo = new MonitorDemo();
 
        // 先启动消费者，让它进入 wait 状态
        Thread consumerThread = new Thread(demo::consumer, "Consumer");
        consumerThread.start();
 
        // 稍等片刻确保消费者先获取锁并进入 wait
        try { Thread.sleep(200); } catch (InterruptedException e) { }
 
        // 再启动生产者
        Thread producerThread = new Thread(demo::producer, "Producer");
        producerThread.start();
    }
}

// 典型输出：
// Consumer 获取锁，检查数据是否就绪...
// Consumer 数据未就绪，调用 wait() 释放锁并等待
// Producer 获取锁，开始生产数据...
// Producer 已通知消费者，但锁还没释放
// Producer 继续持有锁做其他事情...
// Producer 释放了锁
// Consumer 被唤醒，重新获取到锁，再次检查条件
// Consumer 数据已就绪，开始消费！

synchronized (lock) {       // Thread-A 获取锁，_recursions = 1
    synchronized (lock) {   // Thread-A 重入，_recursions = 2
        lock.wait();        // 此处发生了什么？
    }
}

public class SyncBytecodeDemo {
 
    private final Object lock = new Object();
    private int count = 0;
 
    // 场景一：同步代码块
    public void blockSync() {
        synchronized (lock) {       // 进入同步块
            count++;                // 临界区操作
        }                           // 离开同步块
    }
 
    // 场景二：同步实例方法
    public synchronized void methodSync() {
        count++;                    // 整个方法体都是临界区
    }
 
    // 场景三：同步静态方法
    public static synchronized void staticMethodSync() {
        System.out.println("static sync");
    }
}

// javap -c -v 输出（同步代码块部分）
public void blockSync();
    Code:
       0: aload_0                   // 将 this 压入操作数栈
       1: getfield #3               // 获取 this.lock 字段，将 lock 对象引用压栈
       4: dup                       // 复制栈顶的 lock 引用（一份给 monitorenter，一份留给 monitorexit）
       5: astore_1                  // 将复制的 lock 引用存入局部变量表 slot 1（后面 monitorexit 要用）
       6: monitorenter              // ★ 核心指令：弹出栈顶 lock 引用，获取其 Monitor 锁
       7: aload_0                   // 将 this 压栈（准备操作 count 字段）
       8: dup                       // 复制 this 引用
       9: getfield #4               // 获取 this.count 的值
      12: iconst_1                  // 将常量 1 压栈
      13: iadd                      // 栈顶两个 int 相加：count + 1
      14: putfield #4               // 将结果写回 this.count（完成 count++）
      17: aload_1                   // 从局部变量表 slot 1 取出之前保存的 lock 引用
      18: monitorexit               // ★ 核心指令：正常退出，释放 Monitor 锁
      19: goto 27                   // 跳转到方法正常返回处
      22: astore_2                  // ——异常路径开始—— 将异常对象存入 slot 2
      23: aload_1                   // 取出 lock 引用
      24: monitorexit               // ★ 异常退出时也必须释放 Monitor 锁！
      25: aload_2                   // 重新加载异常对象
      26: athrow                    // 重新抛出异常
      27: return                    // 方法正常返回

// javap -c -v 输出（同步实例方法部分）
public synchronized void methodSync();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_SYNCHRONIZED   // ★ 注意这里的 ACC_SYNCHRONIZED 标志
    Code:
       0: aload_0                   // 将 this 压栈
       1: dup                       // 复制 this
       2: getfield #4               // 获取 this.count
       5: iconst_1                  // 常量 1
       6: iadd                      // count + 1
       7: putfield #4               // 写回 count
      10: return                    // 直接返回，没有 monitorenter/monitorexit！

// Exception table（异常表）
//   from    to  target  type
//      7    19    22    any    // 范围 [7, 19) 内的任何异常，跳转到第 22 行处理
//     22    25    22    any    // 范围 [22, 25) 内的任何异常，跳转到第 22 行处理（防止 monitorexit 自身异常）

public class ExceptionReleaseProof {
 
    private static final Object lock = new Object();  // 共享锁对象
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程 A：获取锁后抛出异常
        Thread threadA = new Thread(() -> {
            try {
                synchronized (lock) {                          // monitorenter
                    System.out.println("Thread A: 获取锁");
                    throw new RuntimeException("模拟异常");     // 临界区内抛异常
                }                                              // 编译器保证此处 monitorexit 一定执行
            } catch (RuntimeException e) {
                System.out.println("Thread A: 异常被捕获 - " + e.getMessage());
            }
        }, "Thread-A");
 
        // 线程 B：尝试获取同一把锁
        Thread threadB = new Thread(() -> {
            synchronized (lock) {                              // 如果锁没释放，这里会永远阻塞
                System.out.println("Thread B: 成功获取锁（证明锁已被释放）");
            }
        }, "Thread-B");
 
        threadA.start();       // 启动线程 A
        threadA.join();        // 等待线程 A 执行完毕（包括异常处理）
        threadB.start();       // 启动线程 B
        threadB.join();        // 等待线程 B 执行完毕
    }
}
// 输出：
// Thread A: 获取锁
// Thread A: 异常被捕获 - 模拟异常
// Thread B: 成功获取锁（证明锁已被释放）

public void blockSync() {
    synchronized (this) {
        doSomething();
    }
}

public class Demo {
    // 同步实例方法，锁对象为 this
    public synchronized void methodA() {
        System.out.println("methodA running");
        try { Thread.sleep(2000); } catch (InterruptedException e) {}
    }
 
    // 同步静态方法，锁对象为 Demo.class
    public static synchronized void methodB() {
        System.out.println("methodB running");
        try { Thread.sleep(2000); } catch (InterruptedException e) {}
    }
}

public class Parent {
    public synchronized void doSomething() {
        System.out.println("Parent.doSomething");
    }
}
 
public class Child extends Parent {
    @Override
    public synchronized void doSomething() {
        System.out.println("Child.doSomething");
        // 调用父类的同步方法
        super.doSomething();
    }
}