synchronized 与锁升级原理 ⭐⭐⭐

// 对象刚创建时，处于无锁状态
Object obj = new Object();
// Mark Word：hashCode + 分代年龄 + 0（非偏向）+ 01（无锁）

// 偏向锁获取流程
if (Mark Word 是偏向模式) {
    if (线程 ID 是当前线程) {
        // 直接执行同步块，无需任何同步操作
    } else {
        // CAS 替换线程 ID
        if (CAS 成功) {
            // 获取偏向锁成功
        } else {
            // 撤销偏向锁，升级为轻量级锁
        }
    }
}

// 轻量级锁获取流程
// 1. 在当前线程栈帧中创建 Lock Record
Lock Record lr = new Lock Record();
lr.displaced_header = obj.markWord;

// 2. CAS 将对象头指向 Lock Record
if (CAS(obj.markWord, lr.displaced_header, lr)) {
    // 获取轻量级锁成功
} else {
    // 自旋等待
    for (int i = 0; i < 自旋次数; i++) {
        if (CAS(...)) return;
    }
    // 自旋失败，升级为重量级锁
}

public class LockUpgradeDemo {
    
    // 演示偏向锁
    public static void biasedLock() {
        Object lock = new Object();
        
        // 第一次获取锁，升级为偏向锁
        synchronized (lock) {
            // 偏向线程 A
        }
        
        // 同一线程再次获取，无需同步操作
        synchronized (lock) {
            // 直接执行
        }
    }
    
    // 演示轻量级锁
    public static void lightweightLock() throws InterruptedException {
        Object lock = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                // 线程 A 获取偏向锁
            }
        });
        
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                // 线程 B 竞争，升级为轻量级锁
            }
        });
        
        t1.start();
        t1.join();  // 确保 t1 先执行完
        t2.start();
    }
    
    // 演示重量级锁
    public static void heavyweightLock() {
        Object lock = new Object();
        
        // 多个线程同时竞争
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                synchronized (lock) {
                    // 激烈竞争，升级为重量级锁
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

// JIT 编译器优化：检测到不可能存在竞争，消除锁
public void method() {
    Object lock = new Object();  // 局部变量，不可能逃逸
    synchronized (lock) {        // 锁会被消除
        // do something
    }
}

// 优化前：频繁的加锁解锁
for (int i = 0; i < 100; i++) {
    synchronized (lock) {
        // do something
    }
}

// 优化后：扩大锁范围，减少加锁次数
synchronized (lock) {
    for (int i = 0; i < 100; i++) {
        // do something
    }
}

// 正确用法
synchronized (lock) {
    while (!condition) {
        lock.wait();  // 释放锁，进入等待队列
    }
    // 执行业务逻辑
}

// 错误用法：会抛出 IllegalMonitorStateException
if (!condition) {
    lock.wait();  // 未获取锁就调用 wait
}

// 解锁 happens-before 加锁
// 即：线程 A 解锁后，线程 B 加锁时能看到线程 A 的所有修改

Thread A:
synchronized (lock) {
    x = 1;  // A 的操作
}

Thread B:
synchronized (lock) {
    // 这里一定能看到 x = 1
    System.out.println(x);
}

// 1. 减少锁持有时间
public void method() {
    // 非同步操作
    prepare();
    
    synchronized (lock) {
        // 只同步必要的代码
        criticalSection();
    }
    
    // 非同步操作
    cleanup();
}

// 2. 降低锁粒度
// 不好的做法：一个大锁
public class BigLock {
    private final Object lock = new Object();
    private int count1;
    private int count2;
    
    public void inc1() {
        synchronized (lock) { count1++; }
    }
    
    public void inc2() {
        synchronized (lock) { count2++; }
    }
}

// 好的做法：细粒度锁
public class FineLock {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    private int count1;
    private int count2;
    
    public void inc1() {
        synchronized (lock1) { count1++; }
    }
    
    public void inc2() {
        synchronized (lock2) { count2++; }
    }
}

// 3. 避免嵌套锁（防止死锁）
// 不好的做法
synchronized (lockA) {
    synchronized (lockB) {  // 可能死锁
        // ...
    }
}

// 好的做法：统一获取顺序
Object first = lockA.hashCode() < lockB.hashCode() ? lockA : lockB;
Object second = lockA.hashCode() < lockB.hashCode() ? lockB : lockA;
synchronized (first) {
    synchronized (second) {
        // ...
    }
}