#synchronized原理与锁升级

public class SyncUsage {
    private final Object lock = new Object();
    private int counter = 0;
    
    // 用法1：修饰实例方法，锁对象是this
    public synchronized void increment() {
        counter++;
    }
    
    // 用法2：修饰静态方法，锁对象是Class对象
    public static synchronized void staticMethod() {
        // 操作静态资源
    }
    
    // 用法3：修饰代码块，锁对象是指定的对象
    public void blockMethod() {
        synchronized (lock) {
            counter++;
        }
    }
}

public class SyncDemo {
    public synchronized void method() {
        // 同步方法
    }
    
    public void block() {
        synchronized (this) {
            // 同步代码块
        }
    }
}

public class BiasedLockDemo {
    private final Object lock = new Object();
    
    public void firstThread() {
        synchronized (lock) {
            // 第一次获取锁：升级为偏向锁
            // Mark Word: [thread ID | epoch | age | 1 | 01]
        }
    }
    
    public void sameThreadAgain() {
        synchronized (lock) {
            // 同一个线程再次进入：无需任何操作
            // 因为Mark Word中的thread ID就是自己
        }
    }
}

public class LightweightLockDemo {
    private final Object lock = new Object();
    
    public void threadA() {
        synchronized (lock) {
            // 线程A获取锁，偏向锁
        }
    }
    
    public void threadB() {
        synchronized (lock) {
            // 线程B来竞争，偏向锁被撤销
            // 升级为轻量级锁
            // 线程A和B在用户态自旋等待
        }
    }
}

// 线程栈帧结构
class StackFrame {
    DisplacedMarkWord displaced_mark_word;  // 存储对象头原Mark Word
    Object obj;                              // 指向锁对象
}

public class LightweightLockProcess {
    private final Object lock = new Object();
    
    public void lock() {
        synchronized (lock) {
            // 1. 在线程栈中创建Lock Record
            // 2. 将对象头Mark Word复制到Lock Record
            // 3. CAS尝试将对象头Mark Word更新为指向Lock Record的指针
            //    - 成功：获取轻量级锁
            //    - 失败：自旋重试
        }
    }
}

public void unlock() {
    // 1. CAS将Lock Record中的Mark Word复制回对象头
    // 2. 如果成功：解锁完成
    // 3. 如果失败：说明有竞争，膨胀为重量级锁
}

// JDK 6之前：固定自旋次数
for (int i = 0; i < 10; i++) {
    // 自旋等待
}

// JDK 6之后：自适应自旋
// - 如果上次自旋成功，本次自旋次数增加
// - 如果上次自旋失败，本次自旋次数减少
// - 极端情况下可能不自旋，直接膨胀

// ❌ 粗粒度锁：整个链表加锁
public class BadLinkedList {
    private final Object lock = new Object();
    private Node head;
    
    public void add(Node node) {
        synchronized (lock) {
            // 遍历链表
        }
    }
}

// ✅ 细粒度锁：每个节点独立锁
public class GoodLinkedList {
    private Node head;
    
    public void add(Node node) {
        // 分段锁策略
    }
}

// ✅ 更好的方案：ConcurrentHashMap
Map<String, Object> map = new ConcurrentHashMap<>();
map.put(key, value);  // 分段锁，高并发性能好

public String concat(String a, String b) {
    // JIT识别出这是局部变量，不可能被其他线程访问
    // 消除synchronized
    synchronized (new Object()) {
        return a + b;
    }
}

// ❌ 频繁加解锁
for (int i = 0; i < 1000; i++) {
    synchronized (lock) {
        list.add(i);
    }
}

// ✅ JIT优化为一次加锁
synchronized (lock) {
    for (int i = 0; i < 1000; i++) {
        list.add(i);
    }
}

// ❌ 热点数据用同一把锁
public class HotDataProblem {
    private final Object lock = new Object();
    private int counter1 = 0;
    private int counter2 = 0;
    
    public void inc1() {
        synchronized (lock) {
            counter1++;
        }
    }
    
    public void inc2() {
        synchronized (lock) {
            counter2++;
        }
    }
}

// ✅ 分离热点数据
public class HotDataSolution {
    private AtomicInteger counter1 = new AtomicInteger(0);
    private AtomicInteger counter2 = new AtomicInteger(0);
    
    public void inc1() {
        counter1.incrementAndGet();
    }
    
    public void inc2() {
        counter2.incrementAndGet();
    }
}