synchronized 锁升级：偏向锁 → 轻量级锁 → 重量级锁

"http-nio-8080-exec-42" #42 prio=5 os_prio=31 ...
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.demo.order.OrderService.createOrder(OrderService.java:58)
        - waiting to lock <0x00000007ff8f4d10> (a java.lang.Object)
        at com.demo.order.OrderController.createOrder(...)

public class SyncUsageDemo {

    private int count = 0;
    private final Object lock = new Object();

    // 用法一：修饰实例方法 —— 锁的是 this（当前实例）
    public synchronized void instanceMethod() {
        count++;
    }

    // 用法二：修饰静态方法 —— 锁的是 SyncUsageDemo.class
    public static synchronized void staticMethod() {
        System.out.println("静态方法锁的是 Class 对象");
    }

    // 用法三：修饰代码块 —— 锁的是你指定的对象
    public void blockMethod() {
        synchronized (lock) {
            count++;
        }
    }

    public static void main(String[] args) {
        SyncUsageDemo demo = new SyncUsageDemo();
        demo.instanceMethod();        // 锁 this
        SyncUsageDemo.staticMethod(); // 锁 Class 对象
        demo.blockMethod();           // 锁自定义 lock 对象
    }
}

// 64 位 JVM 下的对象头结构
┌─────────────────────────────────────┐
│ Mark Word（8 字节 = 64 位）        │  ← 锁状态、哈希码、GC 分代年龄
├─────────────────────────────────────┤
│ Klass Pointer（4/8 字节）           │  ← 指向类元数据（开启指针压缩后 4 字节）
├─────────────────────────────────────┤
│ 数组长度（仅数组对象，4 字节）      │  ← 如果是普通对象则没有这部分
└─────────────────────────────────────┘

// 第一次进入 synchronized 块
if (markWord.bias_pattern == 1 && markWord.threadId == 0) {
    // 对象可偏向，且还没有偏向任何线程
    CAS(markWord.threadId, 0, currentThreadId);  // CAS 写入当前线程 ID
    return; // 加锁成功，几乎无开销
}

// 后续进入 synchronized 块
if (markWord.threadId == currentThreadId) {
    return; // 直接放行！不需要任何原子操作
}

// 其他线程来竞争 → 偏向锁撤销 → 升级为轻量级锁
revokeBias();

// 每个线程栈帧中都有若干 Lock Record
// 用于在轻量级锁阶段保存 Mark Word 的备份
struct BasicLock {
    volatile markOop displaced_header;  // 保存对象原始的 Mark Word
};

// 加锁流程：
// 1. 在当前线程栈帧中创建一个 Lock Record
// 2. 把对象的 Mark Word 复制到 Lock Record 的 displaced_header
// 3. CAS 尝试将 Mark Word 替换为指向 Lock Record 的指针
// 4. CAS 成功 → 拿到锁（锁标志位变为 00）
// 5. CAS 失败 → 存在竞争 → 可能膨胀为重量级锁

ObjectMonitor* inflate(Thread* self, oop obj) {
    // 1. 为对象创建一个 ObjectMonitor（如果不存在）
    ObjectMonitor* monitor = new ObjectMonitor();

    // 2. 将对象的 Mark Word 从"指向 Lock Record"改为"指向 ObjectMonitor"
    //    锁标志位从 00 变为 10
    obj->set_mark(markOop::encode(monitor));

    // 3. 将之前持有轻量级锁的线程放入 ObjectMonitor 的 Owner 字段
    monitor->set_owner(lockRecordOwner);

    // 4. 将当前竞争失败的线程放入 EntryList（阻塞队列）
    monitor->enter(self);  // 线程被 park()，进入内核态阻塞

    return monitor;
}

// Java 源码
synchronized (obj) {
    count++;
}

// 编译后的字节码（javap -c 输出）
  0: aload_1           // 加载 obj 到操作数栈
  1: dup               // 复制一份引用（用于 finally 中的 monitorexit）
  2: monitorenter     // 尝试获取 monitor 锁
  3: aload_0
  4: dup
  5: getfield #2      // 读取 count
  8: iconst_1
  9: iadd
 10: putfield #2      // 写回 count++
 13: aload_1
 14: monitorexit      // 正常退出，释放 monitor 锁
 15: goto 23
 18: astore_2          // 异常处理入口
 19: aload_1
 20: monitorexit      // 异常退出，也要释放锁！
 21: athrow            // 重新抛出异常
 23: return

public class ReentrantDemo {

    // 场景一：synchronized 方法嵌套调用
    public synchronized void a() {
        System.out.println("进入 a()，持有锁");
        b();  // 同一个线程再次进入 synchronized —— 可重入，不会死锁
    }

    public synchronized void b() {
        System.out.println("进入 b()，锁可重入");
    }

    // 场景二：递归调用
    public synchronized int factorial(int n) {
        return n <= 1 ? 1 : n * factorial(n - 1);
    }

    public static void main(String[] args) {
        ReentrantDemo demo = new ReentrantDemo();
        demo.a();                          // 嵌套调用，正常运行不卡死
        System.out.println("10! = " + demo.factorial(10)); // 递归，正常运行
    }
}

public class WaitNotifyDemo {

    private static final Object LOCK = new Object();
    private static int count = 0;
    private static final int CAP = 5;   // 容量上限

    public static void main(String[] args) {
        // 生产者：满了就等，不满就生产并唤醒消费者
        new Thread(() -> {
            while (true) {
                synchronized (LOCK) {
                    while (count == CAP) {          // 注意是 while，不是 if
                        try { LOCK.wait(); } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("生产，当前数量: " + (++count));
                    LOCK.notifyAll();                     // 唤醒消费者
                }
            }
        }, "生产者").start();

        // 消费者：空了就等，不空就消费并唤醒生产者
        new Thread(() -> {
            while (true) {
                synchronized (LOCK) {
                    while (count == 0) {          // 注意是 while，不是 if
                        try { LOCK.wait(); } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.println("消费，剩余数量: " + (--count));
                    LOCK.notifyAll();                     // 唤醒生产者
                }
            }
        }, "消费者").start();
    }
}

public String joinNames(List<String> names) {
    StringBuffer sb = new StringBuffer();  // sb 是局部变量，不会逃逸出方法
    for (String name : names) {
        sb.append(name).append(",");      // append 是 synchronized 的
    }
    return sb.toString();                  // 但 sb 没被别的线程看到 → 锁可被消除
}

// 优化前：每次循环都加锁/解锁
for (int i = 0; i < 1000; i++) {
    synchronized (lock) {
        sum += i;
    }
}

// 优化后（JIT 自动粗化）：合并成一把大锁
synchronized (lock) {
    for (int i = 0; i < 1000; i++) {
        sum += i;
    }
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class LockDemo {
    private final ReentrantLock lock = new ReentrantLock();

    public void doJob() {
        try {
            // 等锁过程中可以被 interrupt，也可以超时放弃
            if (lock.tryLock(3, TimeUnit.SECONDS)) {
                try {
                    // 临界区
                } finally {
                    lock.unlock();   // 手动释放，必须 finally
                }
            } else {
                System.out.println("3 秒没拿到锁，放弃");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();  // 恢复中断标志位
        }
    }
}

public class LockObjectDemo {

    // ❌ 错误示范 1：锁 String 字面量 —— 常量池陷阱
    private static final String LOCK = "pay";
    // "pay" 在字符串常量池里全局只有一份！另一个模块也写 synchronized ("pay")，
    // 两把"不同的锁"其实是同一把锁 → 毫无关系的代码互相阻塞，甚至死锁。

    // ❌ 错误示范 2：锁 Integer / Long 包装类型 —— 缓存陷阱
    private static final Integer LOCK2 = 1;
    // Integer.valueOf(1) 命中 -128~127 缓存：所有锁"1"的代码共享同一个 Integer 对象
    // 你的锁可能和 JDK 内部、第三方库的锁撞在一起。

    // ❌ 错误示范 3：锁的引用被重新赋值 —— 锁了个寂寞
    private static Integer counter = 0;
    public static void badIncr() {
        synchronized (counter) {   // 锁的是当前 counter 指向的对象
            counter++;                  // 拆箱 + 加 1 + 装箱 → counter 指向了另一个对象！
        }                               // 下一次加锁锁的是新对象 → 并发完全失效
    }

    // ✅ 正确示范：private final 专用锁对象
    private final Object lock = new Object();  // 每个实例一把独立锁，谁也碰不到
    public void pay() {
        synchronized (lock) {
            // 临界区
        }
    }
}

// 情况一：BLOCKED —— 在 EntryList 排队等锁（等"锁"）
"http-nio-8080-exec-42" #42 ...
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.demo.order.OrderService.createOrder(OrderService.java:58)
        - waiting to lock <0x00000007ff8f4d10> (a java.lang.Object)

// 情况二：WAITING —— 在 WaitSet 等条件（等"通知"）
"pool-1-thread-3" #13 ...
   java.lang.Thread.State: WAITING (parking)
        at jdk.internal.misc.Unsafe.park(Native Method)
        - parking to wait for <0x00000007ff8f4d10> (a java.lang.Object)
        at java.util.concurrent.locks.LockSupport.park(...)

# 1. 抓三把线程快照（间隔 5 秒），避免误判瞬时现象
jstack <pid> > stack1.txt
sleep 5 && jstack <pid> > stack2.txt

# 2. 统计哪个锁对象被最多线程等待
grep "waiting to lock" stack1.txt | sort | uniq -c | sort -rn | head

# 3. 用锁地址反查持锁线程卡在哪
grep "locked <0x00000007ff8f4d10>" stack1.txt stack2.txt stack3.txt