线程生命周期与状态 ⭐⭐

// java.lang.Thread.State 枚举源码（JDK 17+）
public enum State {
    NEW,            // 新建：线程对象已创建，但尚未调用 start()
    RUNNABLE,       // 可运行：已调用 start()，正在 JVM 中执行或等待操作系统调度
    BLOCKED,        // 阻塞：等待获取一个 monitor lock（即 synchronized 锁）
    WAITING,        // 无限等待：调用了 wait()/join()/park()，需要其他线程显式唤醒
    TIMED_WAITING,  // 超时等待：调用了 sleep(n)/wait(n)/parkNanos() 等带超时的方法
    TERMINATED      // 终止：run() 方法执行完毕，或因异常退出
}

// 创建线程对象，此时线程处于 NEW 状态
Thread t = new Thread(() -> {
    System.out.println("Hello from thread"); // 线程体：要执行的任务
});
 
// 验证状态确实是 NEW
System.out.println(t.getState()); // 输出: NEW

Thread t = new Thread(() -> System.out.println("run"));
t.start();  // 第一次调用：正常启动，状态从 NEW → RUNNABLE
t.start();  // 第二次调用：抛出 IllegalThreadStateException！

Thread t = new Thread(() -> {
    // 线程体开始执行，此时线程处于 RUNNABLE 状态
    for (int i = 0; i < 1_000_000; i++) {
        // 执行计算任务
        Math.random(); // CPU 密集型操作，线程持续处于 RUNNABLE
    }
});
t.start(); // 调用 start() 后，状态从 NEW → RUNNABLE
 
// 注意：这里主线程和 t 线程并发执行
// 由于线程调度的不确定性，getState() 的结果取决于调用时机
Thread.sleep(1); // 稍等片刻让 t 线程有机会运行
System.out.println(t.getState()); // 大概率输出: RUNNABLE

┌─────────────────────────────────────────────────┐
│              Java: RUNNABLE                      │
│                                                  │
│   ┌──────────────┐      ┌───────────────────┐   │
│   │  OS: Ready   │ ←──→ │   OS: Running     │   │
│   │ (在就绪队列中 │      │ (正在 CPU 上执行)  │   │
│   │  等待 CPU)   │      │                   │   │
│   └──────────────┘      └───────────────────┘   │
│         ↑    时间片用完 / 被抢占    ↑             │
│         └───────────────────────────┘             │
└─────────────────────────────────────────────────┘

Thread t = new Thread(() -> {
    try {
        // 这个 read() 会阻塞在操作系统层面，等待网络数据到达
        // 但 Java 线程状态仍然是 RUNNABLE，不是 BLOCKED！
        Socket socket = new Socket("example.com", 80);
        socket.getInputStream().read(); // OS 层面阻塞，Java 层面仍是 RUNNABLE
    } catch (Exception e) {
        e.printStackTrace();
    }
});
t.start();
Thread.sleep(100); // 等待线程进入 I/O 阻塞
System.out.println(t.getState()); // 输出: RUNNABLE（不是 BLOCKED！）

// 共享的锁对象
Object lock = new Object();
 
// 线程 A：先获取锁，然后长时间持有
Thread threadA = new Thread(() -> {
    synchronized (lock) {                    // 线程 A 成功获取 lock 的 monitor
        try {
            Thread.sleep(10_000);            // 持有锁 10 秒，模拟长时间操作
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}, "Thread-A");
 
// 线程 B：尝试获取同一把锁，但会被阻塞
Thread threadB = new Thread(() -> {
    synchronized (lock) {                    // 线程 B 尝试获取 lock，但 A 正持有
        System.out.println("Thread B got the lock!"); // 要等 A 释放后才能执行到这里
    }
}, "Thread-B");
 
threadA.start();          // 启动线程 A
Thread.sleep(100);        // 确保 A 先拿到锁
threadB.start();          // 启动线程 B
Thread.sleep(100);        // 等 B 进入阻塞状态
 
System.out.println("Thread-B state: " + threadB.getState()); // 输出: BLOCKED

ReentrantLock reentrantLock = new ReentrantLock();
 
Thread threadC = new Thread(() -> {
    reentrantLock.lock();                    // 获取 ReentrantLock
    try {
        Thread.sleep(10_000);                // 持有锁 10 秒
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        reentrantLock.unlock();              // 释放锁
    }
});
 
Thread threadD = new Thread(() -> {
    reentrantLock.lock();                    // 等待获取 ReentrantLock
    try {
        System.out.println("Thread D got the lock!");
    } finally {
        reentrantLock.unlock();
    }
});
 
threadC.start();
Thread.sleep(100);
threadD.start();
Thread.sleep(100);
 
// 注意！这里不是 BLOCKED，而是 WAITING
System.out.println("Thread-D state: " + threadD.getState()); // 输出: WAITING

Object monitor = new Object();
 
// 演示 Object.wait() 导致的 WAITING 状态
Thread waiter = new Thread(() -> {
    synchronized (monitor) {           // 必须先持有 monitor 锁才能调用 wait()
        try {
            monitor.wait();            // 释放锁，进入 WAITING 状态，无限期等待
            // 被 notify() 唤醒后，会从这里继续执行
            System.out.println("Waiter has been notified!");
        } catch (InterruptedException e) {
            // wait() 能响应中断，抛出 InterruptedException
            Thread.currentThread().interrupt();
        }
    }
}, "Waiter-Thread");
 
waiter.start();
Thread.sleep(100);                     // 确保 waiter 线程已经进入 wait()
 
System.out.println(waiter.getState()); // 输出: WAITING
 
// 唤醒 waiter 线程
synchronized (monitor) {               // 必须持有同一把锁才能调用 notify()
    monitor.notify();                  // 唤醒在 monitor 上等待的一个线程
}

Thread worker = new Thread(() -> {
    try {
        Thread.sleep(5_000);           // 模拟耗时任务，工作 5 秒
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}, "Worker-Thread");
 
Thread boss = new Thread(() -> {
    try {
        worker.join();                 // boss 线程等待 worker 线程执行完毕
        // worker 终止后，boss 从 join() 返回，继续执行
        System.out.println("Worker finished, boss continues.");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}, "Boss-Thread");
 
worker.start();                        // 启动 worker
boss.start();                          // 启动 boss
Thread.sleep(100);                     // 等待 boss 进入 join()
 
System.out.println(boss.getState());   // 输出: WAITING（boss 在等 worker 结束）

// 演示 Thread.sleep() 导致的 TIMED_WAITING 状态
Thread sleeper = new Thread(() -> {
    try {
        Thread.sleep(10_000);          // 休眠 10 秒，进入 TIMED_WAITING
    } catch (InterruptedException e) {
        System.out.println("Sleep was interrupted!");
        Thread.currentThread().interrupt();
    }
}, "Sleeper-Thread");
 
sleeper.start();
Thread.sleep(100);                     // 确保 sleeper 已经进入 sleep
 
System.out.println(sleeper.getState()); // 输出: TIMED_WAITING

// sleep() vs wait(timeout) 的核心区别
 
// sleep()：不释放锁！
synchronized (lock) {
    Thread.sleep(1000);                // 休眠 1 秒，但仍然持有 lock 的 monitor
    // 其他线程在这 1 秒内无法获取 lock
}
 
// wait(timeout)：释放锁！
synchronized (lock) {
    lock.wait(1000);                   // 等待 1 秒，同时释放 lock 的 monitor
    // 其他线程在这 1 秒内可以获取 lock
}

// 正常终止
Thread normalEnd = new Thread(() -> {
    System.out.println("Task done.");  // run() 方法执行完毕，线程自然终止
}, "Normal-End");
 
// 异常终止
Thread abnormalEnd = new Thread(() -> {
    throw new RuntimeException("Oops!"); // 未捕获异常导致线程终止
}, "Abnormal-End");
 
normalEnd.start();
abnormalEnd.start();
Thread.sleep(100);                     // 等待两个线程都执行完
 
System.out.println(normalEnd.getState());   // 输出: TERMINATED
System.out.println(abnormalEnd.getState()); // 输出: TERMINATED

// 设置未捕获异常处理器，避免异常被静默吞掉
Thread t = new Thread(() -> {
    throw new RuntimeException("Something went wrong!");
});
 
// 为线程设置异常处理器
t.setUncaughtExceptionHandler((thread, throwable) -> {
    // 当线程因未捕获异常终止时，这个回调会被触发
    System.err.println("Thread " + thread.getName() + " died: " + throwable.getMessage());
});
 
t.start();

ReentrantLock lock = new ReentrantLock();
 
Thread t1 = new Thread(() -> {
    lock.lock();
    try { Thread.sleep(10_000); }
    catch (InterruptedException e) { }
    finally { lock.unlock(); }
});
 
Thread t2 = new Thread(() -> {
    lock.lock();
    try { System.out.println("t2 acquired lock"); }
    finally { lock.unlock(); }
});
 
t1.start();
Thread.sleep(100);
t2.start();
Thread.sleep(200);
System.out.println(t2.getState());

// 创建线程对象 —— 此时状态为 NEW
Thread t = new Thread(() -> {
    System.out.println("Hello from thread");
});
 
// 验证状态确实是 NEW
System.out.println(t.getState()); // 输出: NEW
 
// 调用 start() —— 状态跃迁为 RUNNABLE
// JVM 在底层调用 os::create_thread() 分配原生线程
// 然后调用 os::start_thread() 让其进入操作系统的就绪队列
t.start();
 
// 注意: 再次调用 start() 会抛出 IllegalThreadStateException
// 因为一个线程的 start() 只能被调用一次
// t.start(); // ❌ 抛异常

public class BlockedDemo {
    // 共享的锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        // 线程A: 先获取锁, 然后长时间持有
        Thread threadA = new Thread(() -> {
            synchronized (lock) {                    // threadA 成功获取 monitor 锁
                try {
                    Thread.sleep(10_000);            // 持有锁 10 秒, 模拟长时间操作
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "Thread-A");
 
        // 线程B: 稍后尝试获取同一把锁
        Thread threadB = new Thread(() -> {
            synchronized (lock) {                    // threadB 尝试获取锁 → 进入 BLOCKED
                System.out.println("Thread-B got the lock!");
            }
        }, "Thread-B");
 
        threadA.start();                             // 启动 A, 它会立即获取锁
        Thread.sleep(100);                           // 确保 A 已经持有锁
        threadB.start();                             // 启动 B
        Thread.sleep(100);                           // 给 B 一点时间去竞争锁
 
        // 此时 threadB 应该处于 BLOCKED 状态
        System.out.println("Thread-B state: " + threadB.getState()); // 输出: BLOCKED
    }
}

┌─────────────────────────────────────────────────────┐
│              Monitor 锁竞争模型                       │
│                                                     │
│   Thread-A ──► synchronized(lock) ──► 成功进入       │
│                     │                               │
│                     ▼                               │
│              ┌─────────────┐                        │
│              │  Monitor 锁  │ ◄── 被 Thread-A 持有   │
│              └─────────────┘                        │
│                     ▲                               │
│                     │                               │
│   Thread-B ──► synchronized(lock) ──► BLOCKED!      │
│                                                     │
│   Thread-C ──► reentrantLock.lock() ──► WAITING!    │
│                (底层调用 LockSupport.park)            │
└─────────────────────────────────────────────────────┘

public class WaitingDemo {
 
    private static final Object monitor = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // ========== 方式一: Object.wait() ==========
        // 必须在 synchronized 块内调用, 否则抛 IllegalMonitorStateException
        Thread t1 = new Thread(() -> {
            synchronized (monitor) {                 // 先获取 monitor 锁
                try {
                    System.out.println("t1: 即将进入 WAITING...");
                    monitor.wait();                  // 释放锁 + 进入 WAITING
                    // 被 notify/notifyAll 唤醒后, 会重新竞争锁
                    // 竞争成功后才从 wait() 返回
                    System.out.println("t1: 被唤醒了!");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }, "wait-thread");
 
        // ========== 方式二: Thread.join() ==========
        // 当前线程等待目标线程执行完毕
        Thread worker = new Thread(() -> {
            try {
                Thread.sleep(2000);                  // 模拟耗时任务
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "worker-thread");
 
        Thread t2 = new Thread(() -> {
            try {
                System.out.println("t2: 等待 worker 完成...");
                worker.join();                       // t2 进入 WAITING, 直到 worker 终止
                // join() 底层实际上调用的是 worker.wait()
                System.out.println("t2: worker 已完成!");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "join-thread");
 
        // ========== 方式三: LockSupport.park() ==========
        // 不需要持有任何锁, 更底层更灵活
        Thread t3 = new Thread(() -> {
            System.out.println("t3: 即将 park...");
            LockSupport.park();                      // 进入 WAITING
            // 被 unpark(t3) 唤醒, 或被中断唤醒
            System.out.println("t3: 被 unpark 了!");
        }, "park-thread");
 
        // 启动演示
        t1.start();
        worker.start();
        t2.start();
        t3.start();
 
        Thread.sleep(500);                           // 等待所有线程进入各自的等待状态
 
        // 打印状态
        System.out.println("t1 state: " + t1.getState());  // WAITING
        System.out.println("t2 state: " + t2.getState());  // WAITING
        System.out.println("t3 state: " + t3.getState());  // WAITING
 
        // 唤醒 t1
        synchronized (monitor) {
            monitor.notify();                        // 唤醒在 monitor 上等待的一个线程
        }
 
        // 唤醒 t3
        LockSupport.unpark(t3);                      // 精确唤醒指定线程, 比 notify 更精准
    }
}

public class TimedWaitingDemo {
 
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 方式一: Thread.sleep(millis) —— 最常见的超时等待
        // 注意: sleep 不会释放任何锁!
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(5000);                  // TIMED_WAITING, 5秒后自动醒来
            } catch (InterruptedException e) {
                System.out.println("t1 被中断了");
            }
        }, "sleep-thread");
 
        // 方式二: Object.wait(timeout) —— 带超时的 wait
        // 与无参 wait() 不同, 超时后自动唤醒
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait(5000);                 // TIMED_WAITING, 释放锁, 5秒后自动醒来
                } catch (InterruptedException e) {
                    System.out.println("t2 被中断了");
                }
            }
        }, "timed-wait-thread");
 
        // 方式三: Thread.join(timeout) —— 最多等目标线程 N 毫秒
        Thread longTask = new Thread(() -> {
            try {
                Thread.sleep(60_000);                // 模拟一个很慢的任务
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "long-task");
 
        Thread t3 = new Thread(() -> {
            try {
                longTask.join(3000);                 // TIMED_WAITING, 最多等 3 秒
                if (longTask.isAlive()) {
                    System.out.println("t3: 等不及了, 不等了!");
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "timed-join-thread");
 
        // 方式四: LockSupport.parkNanos(nanos) / parkUntil(deadline)
        Thread t4 = new Thread(() -> {
            long threeSecondsInNanos = 3_000_000_000L;
            LockSupport.parkNanos(threeSecondsInNanos); // TIMED_WAITING, 3秒后自动醒来
            System.out.println("t4: park 超时, 自动醒来");
        }, "park-nanos-thread");
 
        // 启动所有线程
        t1.start();
        t2.start();
        longTask.start();
        t3.start();
        t4.start();
 
        Thread.sleep(500);                           // 等待线程进入等待状态
 
        // 验证状态
        System.out.println("t1 state: " + t1.getState());  // TIMED_WAITING
        System.out.println("t2 state: " + t2.getState());  // TIMED_WAITING
        System.out.println("t3 state: " + t3.getState());  // TIMED_WAITING
        System.out.println("t4 state: " + t4.getState());  // TIMED_WAITING
    }
}

┌──────────────────────────────────────────────────────────┐
│           sleep() vs wait(timeout) 锁行为对比             │
│                                                          │
│  synchronized(lock) {          synchronized(lock) {      │
│      Thread.sleep(5000);           lock.wait(5000);      │
│      // 锁仍然被持有! ❌            // 锁已释放! ✅        │
│      // 其他线程无法进入            // 其他线程可以进入      │
│  }                             }                         │
│                                                          │
│  sleep: 抱着锁睡觉 (自私)      wait: 放下锁再睡 (礼让)    │
└──────────────────────────────────────────────────────────┘

// 演示 WAITING → BLOCKED → RUNNABLE 的中间态
public class WakeupTransitionDemo {
 
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        // waiter 线程: 获取锁后 wait
        Thread waiter = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();                     // 释放锁, 进入 WAITING
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                // 被唤醒后, 需要重新获取锁才能从 wait() 返回
                System.out.println("waiter: 重新获取锁, 继续执行");
            }
        }, "waiter");
 
        waiter.start();
        Thread.sleep(200);                           // 确保 waiter 已进入 WAITING
 
        // 在 synchronized 块内 notify, 但不立即释放锁
        synchronized (lock) {
            lock.notify();                           // 唤醒 waiter
            // 此时 waiter 被唤醒, 但锁还在我们手里
            // waiter 会从 WAITING 转为 BLOCKED (等待重新获取锁)
            Thread.sleep(100);
            System.out.println("waiter state after notify (lock still held): "
                    + waiter.getState());            // 输出: BLOCKED
        }
        // synchronized 块结束, 释放锁
        // waiter 获取到锁, 从 BLOCKED → RUNNABLE
 
        Thread.sleep(100);
        System.out.println("waiter state after lock released: "
                + waiter.getState());                // 输出: TERMINATED (因为很快就执行完了)
    }
}

// 情况一: run() 方法正常执行完毕
Thread normal = new Thread(() -> {
    System.out.println("任务完成");                   // 执行完这行, run() 结束
    // 隐式 return, 线程进入 TERMINATED
}, "normal-end");
 
// 情况二: run() 方法抛出未捕获的异常
Thread exceptional = new Thread(() -> {
    throw new RuntimeException("出错了!");            // 未捕获异常导致 run() 终止
    // 线程进入 TERMINATED
    // 异常会被 UncaughtExceptionHandler 处理 (如果设置了的话)
}, "exception-end");

Object lock = new Object();
 
Thread t = new Thread(() -> {
    synchronized (lock) {
        try {
            lock.wait(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
});
 
t.start();
Thread.sleep(200);
 
synchronized (lock) {
    lock.notify();
    Thread.sleep(100);
    // 观察点: 此时 t.getState() 是什么?
}

public class BlockedVsWaitingDemo {
 
    // 共享锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程A：先获取锁，然后调用 wait() 主动进入 WAITING
        Thread threadA = new Thread(() -> {
            synchronized (lock) {                    // 获取 lock 的 Monitor 锁
                try {
                    System.out.println("线程A: 已持有锁，准备调用 wait()");
                    lock.wait();                     // 释放锁，进入 WAITING 状态，移入 Wait Set
                    System.out.println("线程A: 被唤醒，重新获得锁，继续执行");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt(); // 恢复中断标志
                }
            }
        }, "Thread-A-WAITING");
 
        // 线程B：尝试获取同一把锁，但锁被占用，被动进入 BLOCKED
        Thread threadB = new Thread(() -> {
            synchronized (lock) {                    // 尝试获取锁，如果锁被占用则进入 BLOCKED
                System.out.println("线程B: 成功获取锁，开始执行");
                lock.notify();                       // 唤醒 Wait Set 中的线程A
                System.out.println("线程B: 已调用 notify()，即将释放锁");
            }
        }, "Thread-B-BLOCKED");
 
        threadA.start();                             // 启动线程A
        Thread.sleep(100);                           // 确保线程A先获取锁并进入 WAITING
 
        // 此时线程A处于 WAITING 状态（已释放锁）
        System.out.println("线程A状态: " + threadA.getState()); // WAITING
 
        // 为了演示 BLOCKED，我们先用主线程把锁抢过来
        synchronized (lock) {                        // 主线程获取锁
            threadB.start();                         // 启动线程B
            Thread.sleep(100);                       // 给线程B时间去竞争锁
 
            // 线程B尝试获取锁但被主线程持有，进入 BLOCKED
            System.out.println("线程B状态: " + threadB.getState()); // BLOCKED
 
            // 线程A仍然在 WAITING（没人 notify 它）
            System.out.println("线程A状态: " + threadA.getState()); // WAITING
        }
        // 主线程释放锁 → 线程B获取锁 → 线程B调用 notify() → 线程A被唤醒
 
        threadA.join();                              // 等待线程A执行完毕
        threadB.join();                              // 等待线程B执行完毕
    }
}

// 线程调用 wait() 的完整生命周期：
// 1. 线程持有 Monitor 锁，是 Owner
// 2. 调用 wait() → 释放锁 → 移入 Wait Set → 状态变为 WAITING
// 3. 其他线程调用 notify() → 从 Wait Set 移入 Entry Set → 状态变为 BLOCKED
// 4. 竞争锁成功 → 状态变为 RUNNABLE → 从 wait() 方法返回
// 
// 所以一个线程从 WAITING 恢复执行，中间会经历一次短暂的 BLOCKED！

/*
 * ┌──────────────┬──────────────────────────────┬──────────────────────────────┐
 * │   对比维度    │          BLOCKED              │          WAITING             │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 触发方式      │ 进入 synchronized 时锁被占用   │ 主动调用 wait()/join()/park() │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 是否持有锁    │ 未持有，正在等待获取           │ wait: 释放锁后等待            │
 * │              │                              │ join/park: 不涉及 Monitor 锁  │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 等待队列      │ Entry Set（入口集）           │ Wait Set（等待集）            │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 唤醒方式      │ 持有锁的线程释放锁，JVM 自动   │ notify/notifyAll/unpark/      │
 * │              │ 从 Entry Set 中选择           │ 目标线程终止(join)             │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 是否响应中断  │ 不响应（不抛 InterruptedException│ wait/join/sleep 响应中断      │
 * │              │ 但中断标志会被设置）            │ park 不抛异常但会返回          │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 是否需要锁    │ 是，必须涉及 synchronized     │ wait 需要，join/park 不需要   │
 * ├──────────────┼──────────────────────────────┼──────────────────────────────┤
 * │ 线程意愿      │ 被动（想执行但拿不到锁）       │ 主动（自愿暂停等待条件）       │
 * └──────────────┴──────────────────────────────┴──────────────────────────────┘
 */

public class InterruptBlockedVsWaiting {
 
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // === 演示1：中断 BLOCKED 线程 ===
        // 主线程先持有锁不释放
        synchronized (lock) {
            Thread blockedThread = new Thread(() -> {
                System.out.println("[BLOCKED] 尝试获取锁...");
                synchronized (lock) {                // 这里会 BLOCKED，因为主线程持有锁
                    // 即使被中断，也要等拿到锁才能执行到这里
                    System.out.println("[BLOCKED] 获取到锁了！中断标志: "
                            + Thread.currentThread().isInterrupted()); // true
                }
            }, "blocked-thread");
 
            blockedThread.start();                   // 启动线程
            Thread.sleep(100);                       // 确保线程进入 BLOCKED
            System.out.println("状态: " + blockedThread.getState()); // BLOCKED
 
            blockedThread.interrupt();               // 中断 BLOCKED 线程
            Thread.sleep(100);                       // 等一下看效果
            System.out.println("中断后状态: " + blockedThread.getState()); // 仍然 BLOCKED！
        }
        // 主线程释放锁后，blockedThread 才能继续
 
        Thread.sleep(500);                           // 等待演示1结束
 
        // === 演示2：中断 WAITING 线程 ===
        Thread waitingThread = new Thread(() -> {
            synchronized (lock) {                    // 先获取锁
                try {
                    System.out.println("[WAITING] 调用 wait()...");
                    lock.wait();                     // 进入 WAITING
                    System.out.println("[WAITING] 正常唤醒");
                } catch (InterruptedException e) {   // 中断会触发这个异常
                    System.out.println("[WAITING] 收到 InterruptedException！");
                    System.out.println("[WAITING] 中断标志: "
                            + Thread.currentThread().isInterrupted()); // false（已被清除）
                }
            }
        }, "waiting-thread");
 
        waitingThread.start();                       // 启动线程
        Thread.sleep(100);                           // 确保线程进入 WAITING
        System.out.println("状态: " + waitingThread.getState()); // WAITING
 
        waitingThread.interrupt();                   // 中断 WAITING 线程 → 立即抛出异常
        waitingThread.join();                        // 等待线程结束
    }
}

// BLOCKED 线程的 Thread Dump 输出示例：
// "Thread-B" #12 prio=5 os_prio=0 tid=0x00007f... nid=0x1a03 
//     waiting for monitor entry [0x00007f...]     ← 关键标识：waiting for monitor entry
//     java.lang.Thread.State: BLOCKED (on object monitor)
//         at com.example.Demo.criticalSection(Demo.java:25)
//         - waiting to lock <0x000000076ab02208>   ← 等待获取这把锁
//           (a java.lang.Object)
//         at com.example.Demo.run(Demo.java:18)
 
// WAITING 线程的 Thread Dump 输出示例：
// "Thread-A" #11 prio=5 os_prio=0 tid=0x00007f... nid=0x1a02
//     in Object.wait() [0x00007f...]              ← 关键标识：in Object.wait()
//     java.lang.Thread.State: WAITING (on object monitor)
//         at java.lang.Object.wait(Native Method)
//         - waiting on <0x000000076ab02208>        ← 在这个对象上等待
//           (a java.lang.Object)
//         at com.example.Demo.run(Demo.java:12)
//         - locked <0x000000076ab02208>            ← 注意：曾经持有过这把锁

public class WaitingToBlockedDemo {
 
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 线程A：获取锁后 wait
        Thread threadA = new Thread(() -> {
            synchronized (lock) {                    // 第1步：获取锁
                try {
                    lock.wait();                     // 第2步：释放锁，进入 WAITING
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                // 第5步：重新获得锁后才能执行到这里
                System.out.println("线程A: 恢复执行");
            }
        }, "Thread-A");
 
        // 线程B：获取锁后 notify，然后做一些耗时操作
        Thread threadB = new Thread(() -> {
            synchronized (lock) {                    // 第3步：获取锁（因为A已经 wait 释放了）
                lock.notify();                       // 第4步：唤醒A，A从 Wait Set 移到 Entry Set
                // 注意！notify() 之后，线程B并没有释放锁！
                // 线程A虽然被唤醒了，但锁还在B手里，所以A变成 BLOCKED
                try {
                    Thread.sleep(3000);              // 模拟耗时操作，锁一直被B持有
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("线程B: 即将释放锁");
            }
            // 第5步：线程B退出 synchronized，释放锁 → 线程A从 BLOCKED 变为 RUNNABLE
        }, "Thread-B");
 
        threadA.start();
        Thread.sleep(100);                           // 确保A先 wait
        threadB.start();
        Thread.sleep(100);                           // 确保B已经 notify 但还没释放锁
 
        // 此时线程A的状态：已被 notify 唤醒，但锁在B手里 → BLOCKED
        System.out.println("线程A状态: " + threadA.getState()); // BLOCKED ！不是 RUNNABLE
        System.out.println("线程B状态: " + threadB.getState()); // TIMED_WAITING (sleep)
 
        threadA.join();
        threadB.join();
    }
}

public class LockVsSynchronized {
 
    private static final ReentrantLock lock = new ReentrantLock();
 
    public static void main(String[] args) throws InterruptedException {
 
        // 用 ReentrantLock 实现可中断的锁等待
        Thread thread = new Thread(() -> {
            try {
                // lockInterruptibly() 在等待锁的过程中可以响应中断
                // 对比 synchronized：一旦进入 BLOCKED 就无法被中断唤醒
                lock.lockInterruptibly();            // 可中断的锁获取
                try {
                    System.out.println("获取到锁，执行业务逻辑");
                } finally {
                    lock.unlock();                   // 必须在 finally 中释放锁
                }
            } catch (InterruptedException e) {
                System.out.println("等待锁的过程中被中断了！");
            }
        });
 
        lock.lock();                                 // 主线程先持有锁
        try {
            thread.start();
            Thread.sleep(100);
 
            // 注意：使用 ReentrantLock 时，等待锁的线程状态是 WAITING，不是 BLOCKED！
            // 因为 ReentrantLock 内部使用 LockSupport.park() 实现等待
            System.out.println("线程状态: " + thread.getState()); // WAITING
 
            thread.interrupt();                      // 可以成功中断！
        } finally {
            lock.unlock();
        }
 
        thread.join();
    }
}

Object obj = new Object();
Thread t = new Thread(() -> {
    synchronized (obj) {
        try {
            obj.wait();
        } catch (InterruptedException e) { }
    }
});
t.start();
Thread.sleep(200);
synchronized (obj) {
    obj.notify();
    // ← 标记处：此时线程 t 的状态是？
    System.out.println(t.getState());
}

// 三个核心 API 一览
thread.interrupt();            // 实例方法：设置目标线程的中断标志为 true
thread.isInterrupted();        // 实例方法：查询目标线程的中断标志，不清除
Thread.interrupted();          // 静态方法：查询【当前】线程的中断标志，并清除为 false

public class InterruptRunningDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个持续工作的线程
        Thread worker = new Thread(() -> {
            long count = 0; // 计数器，模拟工作量
            // 每次循环都主动检查中断标志位
            // 这是协作式中断的关键：线程自己决定何时检查、何时退出
            while (!Thread.currentThread().isInterrupted()) {
                count++; // 模拟业务计算
            }
            // 走到这里说明检测到了中断标志为 true
            System.out.println("检测到中断，已完成 " + count + " 次计算，准备退出");
            // 此时 isInterrupted() 仍然为 true，因为我们只是读取了它
        }, "Worker-Thread");
 
        worker.start(); // 启动工作线程
 
        Thread.sleep(100); // 主线程等待 100ms，让 worker 跑一会儿
 
        // 主线程向 worker 发出中断请求
        // 此时 worker 正在 while 循环中运行（RUNNABLE 状态）
        // interrupt() 只是把 worker 的中断标志设为 true
        worker.interrupt();
 
        worker.join(); // 等待 worker 线程结束
        System.out.println("Worker 已安全退出");
    }
}

public class InterruptSleepingDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread sleeper = new Thread(() -> {
            try {
                System.out.println("准备睡眠 10 秒...");
                // 线程进入 TIMED_WAITING 状态
                Thread.sleep(10_000); // 睡眠 10 秒
                // 如果没有被中断，10 秒后会执行这行
                System.out.println("睡眠正常结束"); // 不会执行到这里
            } catch (InterruptedException e) {
                // sleep 被中断时会抛出此异常
                // 注意：此时中断标志位已经被自动清除为 false！
                System.out.println("睡眠被中断！");
                System.out.println("中断标志位 = " + Thread.currentThread().isInterrupted());
                // 输出: 中断标志位 = false （已被清除）
            }
        }, "Sleeper-Thread");
 
        sleeper.start(); // 启动线程
 
        Thread.sleep(1_000); // 主线程等 1 秒
 
        // 此时 sleeper 正在 sleep 中（TIMED_WAITING 状态）
        // interrupt() 会：1) 让 sleep 立即抛出 InterruptedException
        //                 2) 清除中断标志位
        sleeper.interrupt();
 
        sleeper.join(); // 等待 sleeper 结束
    }
}

public class InterruptBlockedDemo {
    // 一把锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) throws InterruptedException {
        // 线程 A 先拿到锁，并长时间持有
        Thread threadA = new Thread(() -> {
            synchronized (lock) { // threadA 获取锁
                try {
                    System.out.println("线程 A 持有锁，开始长时间工作...");
                    Thread.sleep(10_000); // 持有锁 10 秒
                } catch (InterruptedException e) {
                    // 忽略
                }
            }
        }, "Thread-A");
 
        // 线程 B 尝试获取同一把锁
        Thread threadB = new Thread(() -> {
            System.out.println("线程 B 尝试获取锁...");
            // 此时锁被 threadA 持有，threadB 进入 BLOCKED 状态
            synchronized (lock) {
                // 获取到锁后才能执行到这里
                // 此时才能检查到中断标志
                System.out.println("线程 B 获取到锁！中断标志 = "
                    + Thread.currentThread().isInterrupted());
            }
        }, "Thread-B");
 
        threadA.start(); // 启动 A，让它先拿到锁
        Thread.sleep(500); // 确保 A 已经拿到锁
        threadB.start(); // 启动 B，它会在 synchronized 处阻塞
 
        Thread.sleep(500); // 确保 B 已经进入 BLOCKED 状态
        System.out.println("线程 B 状态: " + threadB.getState()); // BLOCKED
 
        // 对 BLOCKED 状态的线程调用 interrupt()
        // 标志位会被设置，但线程不会从 BLOCKED 中醒来
        threadB.interrupt();
        System.out.println("已对线程 B 调用 interrupt()");
        System.out.println("线程 B 状态仍然是: " + threadB.getState()); // 仍然 BLOCKED
    }
}

public class IsInterruptedDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            int phase = 1; // 任务阶段编号
 
            // 用 isInterrupted() 作为循环退出条件
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("执行阶段 " + phase + " 的任务...");
                phase++;
 
                // 模拟每个阶段的耗时操作（纯计算，不涉及阻塞）
                // 注意：这里故意不用 sleep，因为 sleep 会改变中断标志的语义
                long start = System.nanoTime();
                // 自旋等待约 50ms，模拟 CPU 密集型工作
                while (System.nanoTime() - start < 50_000_000L) {
                    // busy-wait（仅用于演示，实际开发中不推荐）
                }
            }
 
            // 退出循环后，中断标志仍然为 true（isInterrupted 不清除标志）
            System.out.println("收到中断信号，在阶段 " + phase + " 退出");
            System.out.println("退出后标志位 = " + Thread.currentThread().isInterrupted());
            // 输出: true —— 标志位没有被清除
 
            // 可以再次检查，仍然是 true
            System.out.println("再次检查 = " + Thread.currentThread().isInterrupted());
            // 输出: true —— 依然没有被清除
        }, "Worker");
 
        worker.start();       // 启动工作线程
        Thread.sleep(200);    // 让 worker 运行 200ms
        worker.interrupt();   // 发出中断请求
        worker.join();        // 等待 worker 退出
    }
}

public class InterruptedStaticDemo {
    public static void main(String[] args) {
        // 主线程中断自己（用于演示）
        Thread.currentThread().interrupt();
 
        // 第一次调用 Thread.interrupted()
        // 返回 true（标志位确实为 true），然后立即清除标志位为 false
        System.out.println("第一次调用: " + Thread.interrupted());  // true
 
        // 第二次调用 Thread.interrupted()
        // 返回 false（标志位已经在上一次调用时被清除了）
        System.out.println("第二次调用: " + Thread.interrupted());  // false
 
        // 对比 isInterrupted()：不会清除标志位
        Thread.currentThread().interrupt(); // 再次设置标志位
        System.out.println("isInterrupted 第一次: "
            + Thread.currentThread().isInterrupted()); // true
        System.out.println("isInterrupted 第二次: "
            + Thread.currentThread().isInterrupted()); // true —— 没有被清除
    }
}

public class InterruptedTrapDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            // worker 线程在这里运行
            while (!Thread.interrupted()) { // 检查的是 worker 自己的标志
                // 工作中...
            }
            System.out.println("Worker 退出");
        }, "Worker");
 
        worker.start();
        Thread.sleep(100);
        worker.interrupt(); // 中断 worker
 
        // ⚠️ 下面这行代码看起来像是在检查 worker 的中断状态
        // 但实际上 interrupted() 是静态方法，检查的是【当前线程】即 main 线程！
        // 这是一个非常常见的误用
        System.out.println("worker.interrupted() = " + worker.interrupted());
        // 实际等价于 Thread.interrupted()，检查的是 main 线程，输出 false
 
        // 正确做法：用实例方法 isInterrupted() 检查其他线程的状态
        // 但此时 worker 可能已经退出了，标志位可能已被清除
    }
}

// ❌ 错误示范：吞掉中断信号
public void badExample() {
    while (true) {
        try {
            // 执行一些可中断的阻塞操作
            Thread.sleep(1000);
            doWork();
        } catch (InterruptedException e) {
            // 什么都不做，或者只是打印日志
            // 中断标志已经被清除，循环会继续执行
            // 调用者永远无法通过中断来停止这个线程！
            System.out.println("被中断了，但我选择忽略"); // ❌ 极其危险
        }
    }
}

// ✅ 正确示范：向上传播异常
// 方法签名中声明 throws InterruptedException
// 让调用者自己决定如何处理中断
public void fetchDataFromRemote() throws InterruptedException {
    // 如果 sleep 期间被中断，异常会自动向上传播
    // 调用者能感知到中断的发生
    Thread.sleep(2000); // 模拟网络延迟
    processResponse();  // 处理响应
}
 
// 调用者可以继续传播，或者在合适的层级处理
public void businessLogic() throws InterruptedException {
    fetchDataFromRemote(); // 异常继续向上传播
}

// ✅ 正确示范：恢复中断状态
public class ProperInterruptHandling implements Runnable {
    @Override
    public void run() { // Runnable.run() 不允许抛出受检异常
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 执行可中断的阻塞操作
                Thread.sleep(1000);
                doWork();
            } catch (InterruptedException e) {
                // sleep 抛出异常时，中断标志已被清除为 false
                // 必须重新设置中断标志！
                // 这样 while 循环的条件检查才能感知到中断
                Thread.currentThread().interrupt(); // ✅ 恢复中断状态
 
                // 可以在这里做一些清理工作
                System.out.println("收到中断信号，执行清理后退出...");
                cleanup(); // 释放资源、关闭连接等
                // 下一次循环条件检查时，isInterrupted() 返回 true，循环退出
            }
        }
        System.out.println("线程安全退出");
    }
 
    private void doWork() { /* 业务逻辑 */ }
    private void cleanup() { /* 资源清理 */ }
}

public class BatchProcessor implements Runnable {
    private final List<String> dataList;       // 待处理的数据列表
    private volatile int processedCount = 0;   // 已处理数量（volatile 保证可见性）
 
    public BatchProcessor(List<String> dataList) {
        this.dataList = dataList; // 初始化数据列表
    }
 
    @Override
    public void run() {
        System.out.println("开始批量处理，共 " + dataList.size() + " 条数据");
 
        try {
            for (int i = 0; i < dataList.size(); i++) {
                // 在每次迭代开始时检查中断状态
                // 这是处理 CPU 密集型任务时的最佳实践
                if (Thread.currentThread().isInterrupted()) {
                    // 检测到中断，主动退出循环
                    System.out.println("在第 " + i + " 条数据处检测到中断标志");
                    break; // 跳出循环，进入 finally 做清理
                }
 
                // 模拟处理每条数据（可能包含 IO 操作）
                processItem(dataList.get(i)); // 可能抛出 InterruptedException
                processedCount = i + 1;       // 更新已处理计数
            }
        } catch (InterruptedException e) {
            // 如果在 processItem 内部的阻塞操作中被中断
            // 异常被捕获，中断标志已被清除
            System.out.println("在处理数据时被中断（阻塞操作中）");
            // 恢复中断状态，让外层框架（如线程池）也能感知到中断
            Thread.currentThread().interrupt(); // ✅ 恢复中断
        } finally {
            // finally 块确保无论如何都会执行清理和汇报
            System.out.println("处理完毕：共处理 " + processedCount
                + " / " + dataList.size() + " 条数据");
        }
    }
 
    // 模拟处理单条数据，包含可中断的阻塞操作
    private void processItem(String item) throws InterruptedException {
        // 模拟耗时的 IO 操作（如数据库写入、网络请求）
        // sleep 是可中断的，如果此时收到中断，会抛出 InterruptedException
        Thread.sleep(100); // 向上传播异常，不在这里 catch ✅
    }
 
    // 提供查询进度的方法
    public int getProcessedCount() {
        return processedCount; // volatile 保证读取到最新值
    }
}

public class InterruptQuiz {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            Thread.currentThread().interrupt();
            System.out.println("A: " + Thread.currentThread().isInterrupted());
            System.out.println("B: " + Thread.interrupted());
            System.out.println("C: " + Thread.interrupted());
            System.out.println("D: " + Thread.currentThread().isInterrupted());
        });
        t.start();
    }
}

public class BankAccount {
    // 账户余额
    private int balance;
    // 交易日志记录数
    private int transactionCount;
 
    // 转账操作：需要同时更新余额和交易计数
    // 这两步必须作为一个原子操作完成
    public synchronized void transfer(int amount) {
        // 第一步：扣减余额
        balance -= amount;
 
        // ⚠️ 假设 stop() 恰好在这里触发了 ThreadDeath
        // 余额已经扣了，但交易记录还没 +1
        // stop() 会释放 synchronized 锁
        // 其他线程看到的就是：钱少了，但没有对应的交易记录
 
        // 模拟一些中间处理耗时
        doSomeProcessing();
 
        // 第二步：记录交易次数
        transactionCount++;
    }
 
    private void doSomeProcessing() {
        // 一些业务逻辑...
    }
}

public void run() {
    try {
        // 业务逻辑
        doWork();
    } catch (ThreadDeath td) {
        // 你以为你能在这里做清理工作？
        // 问题是：ThreadDeath 可以在任意时刻、任意代码行抛出
        // 甚至在你的清理代码执行过程中，又一个 stop() 调用
        // 可能再次抛出 ThreadDeath
        cleanup(); // ← 这段代码本身也可能被 stop() 打断
        throw td;  // 按规范需要重新抛出
    }
}

public class SharedResource {
    private final Object lockA = new Object();
    private final Object lockB = new Object();
 
    public void criticalOperation() {
        // 获取锁 A
        synchronized (lockA) {
            // 修改被锁 A 保护的数据（已完成一半）
            modifyDataA();
 
            // 获取锁 B
            synchronized (lockB) {
                // ⚠️ stop() 在此触发
                // 结果：lockA 和 lockB 同时被释放
                // dataA 处于不一致状态，dataB 也可能不一致
                // 其他等待这两把锁的线程全部被"放行"
                // 它们看到的是一片混乱的数据
                modifyDataB();
            }
        }
    }
 
    private void modifyDataA() { /* ... */ }
    private void modifyDataB() { /* ... */ }
}

public class VolatileFlagTermination implements Runnable {
 
    // volatile 保证多线程间的可见性
    // 当主线程将其设为 true 时，工作线程能立即看到
    private volatile boolean stopped = false;
 
    // 对外暴露的停止方法
    public void stop() {
        // 设置停止标志为 true
        stopped = true;
    }
 
    @Override
    public void run() {
        // 核心：每次循环迭代都检查停止标志
        while (!stopped) {
            // 执行实际的业务逻辑
            doWork();
        }
 
        // 线程自己走到这里，说明收到了停止信号
        // 在这里做清理工作，一切尽在掌控
        cleanup();
        // run() 方法正常返回，线程优雅终止
        System.out.println("线程已安全终止，资源已清理完毕");
    }
 
    private void doWork() {
        // 模拟业务处理
        System.out.println("正在处理任务...");
        try {
            // 模拟耗时操作
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // sleep 被中断时也应该配合退出
            Thread.currentThread().interrupt();
        }
    }
 
    private void cleanup() {
        // 关闭文件句柄、数据库连接、释放资源等
        System.out.println("正在清理资源...");
    }
 
    public static void main(String[] args) throws InterruptedException {
        // 创建任务实例
        VolatileFlagTermination task = new VolatileFlagTermination();
        // 启动工作线程
        Thread worker = new Thread(task, "Worker-Thread");
        worker.start();
 
        // 主线程等待 3 秒后发出停止信号
        Thread.sleep(3000);
        // 通知工作线程停止
        task.stop();
        System.out.println("已发送停止信号");
 
        // 等待工作线程真正结束
        worker.join();
        System.out.println("工作线程已完全退出");
    }
}

public class InterruptTermination implements Runnable {
 
    @Override
    public void run() {
        // 通过检查中断状态来决定是否继续运行
        // Thread.currentThread().isInterrupted() 不会清除中断标志
        while (!Thread.currentThread().isInterrupted()) {
            try {
                // 执行业务逻辑
                doWork();
 
                // 即使线程正在 sleep，interrupt() 也能将其唤醒
                // 唤醒后会抛出 InterruptedException
                Thread.sleep(500);
 
            } catch (InterruptedException e) {
                // 捕获到 InterruptedException 说明有人请求中断
                // 注意：捕获该异常后，中断标志会被自动清除
                System.out.println("收到中断信号，准备退出...");
 
                // 执行清理工作
                cleanup();
 
                // 有两种选择：
                // 选择 1：直接 return 退出（适用于顶层 run 方法）
                // 选择 2：重新设置中断标志，让上层调用者也能感知
                // Thread.currentThread().interrupt();
 
                // 这里我们选择直接退出
                return;
            }
        }
 
        // 如果是通过 while 条件退出的（非阻塞状态下被中断）
        cleanup();
        System.out.println("线程通过中断标志检查正常退出");
    }
 
    private void doWork() {
        System.out.println("正在处理任务...");
    }
 
    private void cleanup() {
        System.out.println("正在清理资源...");
    }
 
    public static void main(String[] args) throws InterruptedException {
        // 创建并启动工作线程
        Thread worker = new Thread(new InterruptTermination(), "Worker");
        worker.start();
 
        // 主线程等待 3 秒
        Thread.sleep(3000);
 
        // 发送中断信号
        // 如果 worker 正在 sleep/wait/join，会立即抛出 InterruptedException
        // 如果 worker 正在正常运行，会设置中断标志位
        worker.interrupt();
        System.out.println("已发送中断信号");
 
        // 等待工作线程结束
        worker.join();
        System.out.println("工作线程已完全退出");
    }
}

public class RobustTermination implements Runnable {
 
    // volatile 标志位：提供明确的"是否应该停止"语义
    private volatile boolean stopped = false;
 
    // 保存线程引用，用于发送中断信号
    private volatile Thread workerThread;
 
    // 对外暴露的停止方法：双管齐下
    public void stop() {
        // 第一步：设置标志位
        stopped = true;
        // 第二步：发送中断信号，唤醒可能阻塞的线程
        if (workerThread != null) {
            workerThread.interrupt();
        }
    }
 
    @Override
    public void run() {
        // 记录当前工作线程的引用
        workerThread = Thread.currentThread();
 
        try {
            // 同时检查两个条件：标志位 和 中断状态
            while (!stopped && !Thread.currentThread().isInterrupted()) {
                try {
                    // 业务逻辑
                    doWork();
 
                    // 可能的阻塞操作
                    Thread.sleep(1000);
 
                } catch (InterruptedException e) {
                    // 被中断唤醒，配合标志位一起判断
                    // 重新设置中断标志（因为 catch 后会被清除）
                    Thread.currentThread().interrupt();
                    // while 循环的条件检查会让线程退出
                }
            }
        } finally {
            // finally 块确保清理逻辑一定会执行
            // 无论是正常退出还是异常退出
            cleanup();
            System.out.println("线程已安全终止");
        }
    }
 
    private void doWork() {
        System.out.println("[" + Thread.currentThread().getName() + "] 处理中...");
    }
 
    private void cleanup() {
        // 关闭 IO 流、释放数据库连接、保存状态等
        System.out.println("执行清理：关闭连接、释放资源...");
    }
}

// 选择 1：传播 —— 在方法签名上声明 throws InterruptedException
// 让调用者去决定如何处理
public void myMethod() throws InterruptedException {
    // 调用可能阻塞的方法
    Thread.sleep(1000);
    // 如果被中断，异常会自动向上传播
}
 
// 选择 2：恢复中断标志 —— 捕获异常后重新设置中断状态
// 适用于不能在签名上声明异常的场景（如实现 Runnable 接口）
public void run() {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        // 捕获后中断标志被清除了，必须恢复它
        // 这样上层代码（或循环条件）才能感知到中断
        Thread.currentThread().interrupt();
    }
}

// ❌ 错误示范：吞掉中断，假装什么都没发生
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // 什么都不做，或者只打个日志
    // 中断标志已被清除，上层代码永远不知道有人请求了中断
    // 线程会继续运行，无法被终止
    e.printStackTrace(); // 这不叫处理，这叫掩耳盗铃
}
 
// ✅ 正确示范：至少恢复中断标志
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    // 记录日志是好的
    logger.warn("线程被中断", e);
    // 但必须恢复中断标志
    Thread.currentThread().interrupt();
}