synchronized 关键字

// 1. 同步实例方法 - 锁的是 this 对象
public synchronized void instanceMethod() {
    // 临界区代码
}
 
// 2. 同步静态方法 - 锁的是 Class 对象
public static synchronized void staticMethod() {
    // 临界区代码
}
 
// 3. 同步代码块 - 锁的是指定对象
public void blockMethod() {
    synchronized (this) {  // 或任意对象
        // 临界区代码
    }
}

public class SyncDemo {
    // 对象锁 - 不同实例不互斥
    public synchronized void methodA() {}
    
    // 类锁 - 所有实例互斥
    public static synchronized void methodB() {}
    
    // 等价于类锁
    public void methodC() {
        synchronized (SyncDemo.class) {}
    }
}

// 第一次获取锁：CAS 修改对象头中的线程 ID
// 后续进入：检查线程 ID，相同则直接进入

线程栈帧                    对象头
┌─────────────┐            ┌─────────────┐
│ Lock Record │ ──CAS──→   │ Mark Word   │
│ (锁记录)    │            │ (存储锁记录地址) │
└─────────────┘            └─────────────┘

无锁
  ↓ (单线程首次访问)
偏向锁 (记录线程ID)
  ↓ (其他线程竞争)
轻量级锁 (CAS + 自旋)
  ↓ (自旋失败/竞争激烈)
重量级锁 (Mutex 阻塞)

public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();  // sb 是局部变量，不会被逃逸
    sb.append(s1);
    sb.append(s2);
    return sb.toString();
    // StringBuffer 的 append 是同步方法，但 sb 不会逃逸
    // JIT 会消除这里的锁
}

// 优化前：循环内加锁
for (int i = 0; i < 100; i++) {
    synchronized (lock) {
        list.add(i);
    }
}
 
// 优化后：锁粗化到循环外
synchronized (lock) {
    for (int i = 0; i < 100; i++) {
        list.add(i);
    }
}

// ReentrantLock 使用示例
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
 
lock.lock();
try {
    while (条件不满足) {
        condition.await();
    }
    // 执行逻辑
    condition.signalAll();
} finally {
    lock.unlock();  // 必须在 finally 中释放
}

public class ReentrantDemo {
    public synchronized void methodA() {
        methodB();  // 可以再次获取同一把锁
    }
    
    public synchronized void methodB() {
        // 正常执行
    }
}