线程生命周期：6 种状态与 12 次转换

public enum State {
    NEW,            // Thread object created but start() not yet called.
    RUNNABLE,       // Executing in the JVM — may be waiting for OS resources (e.g. CPU).
    BLOCKED,        // Waiting to acquire a monitor lock (synchronized block/method).
    WAITING,        // Waiting indefinitely for another thread's action (wait, park, join).
    TIMED_WAITING,  // Waiting up to a specified time (sleep, wait(ms), parkNanos).
    TERMINATED      // The thread has completed execution.
}

// 1. NEW
Thread t1 = new Thread(() -> {});
System.out.println(t1.getState()); // NEW

// 2. RUNNABLE
Thread t2 = new Thread(() -> {
    while (true) { Thread.yield(); }
});
t2.start();
System.out.println(t2.getState()); // RUNNABLE

// 3. BLOCKED
Object lock = new Object();
Thread holder = new Thread(() -> {
    synchronized (lock) {
        try { Thread.sleep(999999); } catch (Exception e) {}
    }
});
holder.start();
Thread.sleep(100); // 等 holder 拿到锁
Thread t3 = new Thread(() -> {
    synchronized (lock) {} // 拿不到锁 → BLOCKED
});
t3.start();
Thread.sleep(100);
System.out.println(t3.getState()); // BLOCKED

// 4. WAITING
Thread t4 = new Thread(() -> {
    synchronized (lock) {
        try { lock.wait(); } catch (Exception e) {}
    }
});
// ... start + sleep → WAITING

// 5. TIMED_WAITING
Thread t5 = new Thread(() -> {
    try { Thread.sleep(60000); } catch (Exception e) {}
});
t5.start();
Thread.sleep(100);
System.out.println(t5.getState()); // TIMED_WAITING

// 6. TERMINATED
Thread t6 = new Thread(() -> {});
t6.start();
t6.join();
System.out.println(t6.getState()); // TERMINATED

// ━━━ 场景 1：synchronized → BLOCKED ━━━
Object monitor = new Object();

Thread t1 = new Thread(() -> {
    synchronized (monitor) {
        Thread.sleep(10000); // 持锁休眠
    }
});

Thread t2 = new Thread(() -> {
    synchronized (monitor) { // 拿不到锁 → BLOCKED
        System.out.println("拿到了");
    }
});

// ━━━ 场景 2：ReentrantLock → WAITING ━━━
ReentrantLock lock = new ReentrantLock();

Thread t3 = new Thread(() -> {
    lock.lock();
    try {
        Thread.sleep(10000); // 持锁休眠
    } finally { lock.unlock(); }
});

Thread t4 = new Thread(() -> {
    lock.lock(); // 拿不到锁 → WAITING（不是 BLOCKED！）
    try {
        System.out.println("拿到了");
    } finally { lock.unlock(); }
});

$ jstack 12345
Full thread dump OpenJDK 64-Bit Server VM (17.0.2+8):

"worker-1" #11 prio=5 os_prio=0 tid=0x00007f3a1c0e8800 nid=0x2a03
  waiting for monitor entry [0x00007f3a08ffe000]
  java.lang.Thread.State: BLOCKED (on object monitor)
    at com.example.OrderService.process(OrderService.java:42)
    - waiting to lock <0x000000076bf62208> (a java.lang.Object)
    at com.example.Worker.run(Worker.java:18)

"worker-2" #12 prio=5 os_prio=0 tid=0x00007f3a1c0ea000 nid=0x2a04
  in Object.wait() [0x00007f3a08efe000]
  java.lang.Thread.State: WAITING (on object monitor)
    at java.lang.Object.wait(Native Method)
    - waiting on <0x000000076bf62208> (a java.lang.Object)
    at java.lang.Object.wait(Object.java:328)
    at com.example.Consumer.consume(Consumer.java:35)

"timer-1" #13 prio=5 os_prio=0 tid=0x00007f3a1c0ec000 nid=0x2a05
  sleeping [0x00007f3a08dfe000]
  java.lang.Thread.State: TIMED_WAITING (sleeping)
    at java.lang.Thread.sleep(Native Method)
    at com.example.Scheduler.poll(Scheduler.java:22)

"main" #1 prio=5 os_prio=0 tid=0x00007f3a1c010800 nid=0x2901
  runnable [0x00007f3a23ffe000]
  java.lang.Thread.State: RUNNABLE
    at com.example.App.main(App.java:15)

# 第一步：导出线程转储
jstack -l <pid> > thread_dump.txt

# 第二步：搜索 BLOCKED 状态的线程
grep -A 5 "BLOCKED" thread_dump.txt

# 第三步：根据锁地址找到持有者
grep "0x000000076bf62208" thread_dump.txt
# → 看到 worker-2 执行 wait() 时释放了锁
# → 看到 worker-1 在等这把锁 → 检查是否有死锁

# 如果 jstack 末尾出现 "Found one Java-level deadlock"：
# → 恭喜，确认死锁了。根据循环依赖链修复代码。