线程基础 ⭐

┌─────────────────────────────────────────────────────────────┐
│                    JVM 进程 (Process)                        │
│                                                             │
│  ┌──────────────────── 共享区域 ────────────────────────┐    │
│  │  方法区 (Method Area / Metaspace)                    │    │
│  │  ┌──────────────────────────────────────────────┐    │    │
│  │  │ 类信息、常量池、静态变量、JIT 编译后代码       │    │    │
│  │  └──────────────────────────────────────────────┘    │    │
│  │                                                      │    │
│  │  堆 (Heap)                                           │    │
│  │  ┌──────────────────────────────────────────────┐    │    │
│  │  │ 所有对象实例（new 出来的）、数组               │    │    │
│  │  │ GC 在此工作                                    │    │    │
│  │  └──────────────────────────────────────────────┘    │    │
│  └──────────────────────────────────────────────────────┘    │
│                                                             │
│  ┌─── Thread-0 (私有) ───┐  ┌─── Thread-1 (私有) ───┐      │
│  │ PC: 0x00A3            │  │ PC: 0x00F7            │      │
│  │ 虚拟机栈 (VM Stack)   │  │ 虚拟机栈 (VM Stack)   │      │
│  │  ┌──────────────┐     │  │  ┌──────────────┐     │      │
│  │  │ 栈帧 Frame-2 │     │  │  │ 栈帧 Frame-1 │     │      │
│  │  │ 栈帧 Frame-1 │     │  │  │ 栈帧 Frame-0 │     │      │
│  │  │ 栈帧 Frame-0 │     │  │  └──────────────┘     │      │
│  │  └──────────────┘     │  │                        │      │
│  │ 本地方法栈             │  │ 本地方法栈             │      │
│  └───────────────────────┘  └────────────────────────┘      │
└─────────────────────────────────────────────────────────────┘

public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建线程，此时状态为 NEW
        Thread t = new Thread(() -> {
            try {
                // sleep 会使线程进入 TIMED_WAITING 状态
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // 中断异常处理
                Thread.currentThread().interrupt();
            }
        });
 
        // 打印 NEW 状态
        System.out.println("创建后: " + t.getState());   // NEW
 
        // 启动线程，状态变为 RUNNABLE
        t.start();
        // 给线程一点时间进入 sleep
        Thread.sleep(100);
 
        // 此时线程正在 sleep，状态为 TIMED_WAITING
        System.out.println("sleep中: " + t.getState());  // TIMED_WAITING
 
        // 等待线程执行完毕
        t.join();
 
        // 线程结束，状态为 TERMINATED
        System.out.println("结束后: " + t.getState());   // TERMINATED
    }
}

// 1. 定义一个类，继承 Thread
public class MyThread extends Thread {
 
    // 2. 重写 run() 方法，定义线程执行的任务
    @Override
    public void run() {
        // 获取当前线程的名称，Thread 内部维护了一个 name 字段
        String name = Thread.currentThread().getName();
        // 模拟业务逻辑：循环打印信息
        for (int i = 0; i < 5; i++) {
            System.out.println(name + " 正在执行第 " + i + " 次任务");
        }
    }
 
    public static void main(String[] args) {
        // 3. 创建线程对象
        MyThread t1 = new MyThread();
        // 可以为线程设置一个有意义的名字，便于调试
        t1.setName("Worker-1");
 
        // 4. 调用 start() 启动线程（而非直接调用 run()）
        t1.start();
 
        // main 线程继续执行自己的逻辑
        System.out.println("main 线程继续运行...");
    }
}

main 线程继续运行...
Worker-1 正在执行第 0 次任务
Worker-1 正在执行第 1 次任务
Worker-1 正在执行第 2 次任务
Worker-1 正在执行第 3 次任务
Worker-1 正在执行第 4 次任务

// Runnable 接口的定义（JDK 源码）
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

// 方式一：传统写法 —— 实现 Runnable 接口
public class MyTask implements Runnable {
 
    // 实现 run() 方法，定义任务逻辑
    @Override
    public void run() {
        // 获取当前执行此任务的线程名
        String name = Thread.currentThread().getName();
        System.out.println(name + " 正在执行任务");
    }
 
    public static void main(String[] args) {
        // 1. 创建任务对象（注意：它不是线程，只是一个任务）
        MyTask task = new MyTask();
 
        // 2. 将任务传给 Thread 对象，由 Thread 负责线程管理
        Thread t1 = new Thread(task, "Worker-A");
        // 3. 启动线程
        t1.start();
 
        // 方式二：匿名内部类写法（适用于一次性任务）
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " 匿名任务执行");
            }
        }, "Worker-B");
        t2.start();
 
        // 方式三：Lambda 表达式（Java 8+，最简洁）
        // 因为 Runnable 是 @FunctionalInterface，所以可以用 Lambda
        Thread t3 = new Thread(() -> {
            // Lambda 体就是 run() 的实现
            System.out.println(Thread.currentThread().getName() + " Lambda 任务执行");
        }, "Worker-C");
        t3.start();
    }
}

// Thread.java 简化源码
public class Thread implements Runnable {
    // target 就是通过构造器传入的 Runnable 对象
    private Runnable target;
 
    // Thread 自身的 run() 方法
    @Override
    public void run() {
        // 如果传入了 Runnable，就委托给它执行
        if (target != null) {
            target.run();
        }
        // 如果没传入，也没重写 run()，则什么也不做
    }
}

// Callable 接口的定义（JDK 源码）
@FunctionalInterface
public interface Callable<V> {
    // 可以返回结果 V，也可以抛出受检异常
    V call() throws Exception;
}

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ExecutionException;
 
public class CallableDemo {
 
    public static void main(String[] args) {
        // 1. 定义一个 Callable 任务，泛型指定返回值类型为 Integer
        Callable<Integer> task = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                System.out.println(Thread.currentThread().getName() + " 开始计算...");
                int sum = 0;
                // 模拟一个耗时的累加任务
                for (int i = 1; i <= 100; i++) {
                    sum += i;                       // 累加 1 到 100
                    Thread.sleep(10);               // 模拟耗时操作
                }
                System.out.println(Thread.currentThread().getName() + " 计算完成!");
                return sum;                         // 返回计算结果
            }
        };
 
        // 2. 用 FutureTask 包装 Callable（适配器模式）
        //    FutureTask 既是 Runnable（可传给 Thread），又是 Future（可获取结果）
        FutureTask<Integer> futureTask = new FutureTask<>(task);
 
        // 3. 将 FutureTask 传给 Thread 并启动
        Thread thread = new Thread(futureTask, "Calc-Thread");
        thread.start();
 
        // 4. main 线程可以继续执行其他工作
        System.out.println("main 线程正在做其他事情...");
 
        try {
            // 5. 调用 get() 获取结果 —— 这是一个阻塞调用！
            //    如果 Calc-Thread 还没执行完，main 线程会在此等待
            Integer result = futureTask.get();
            System.out.println("计算结果: " + result);     // 输出: 计算结果: 5050
        } catch (InterruptedException e) {
            // 当前线程在等待过程中被中断
            Thread.currentThread().interrupt();
            System.err.println("等待被中断");
        } catch (ExecutionException e) {
            // call() 方法内部抛出了异常，包装在 ExecutionException 中
            System.err.println("任务执行异常: " + e.getCause());
        }
    }
}

// Lambda 简化版
FutureTask<Integer> futureTask = new FutureTask<>(() -> {
    int sum = 0;                                // 初始化累加器
    for (int i = 1; i <= 100; i++) {
        sum += i;                               // 累加
    }
    return sum;                                 // 返回结果，编译器自动推断为 Integer
});
 
new Thread(futureTask, "Calc-Thread").start();  // 启动线程
Integer result = futureTask.get();              // 阻塞获取结果

try {
    // 最多等待 5 秒，超时则抛出 TimeoutException
    Integer result = futureTask.get(5, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    System.err.println("任务超时，考虑取消任务...");
    futureTask.cancel(true);        // 尝试中断正在执行的线程
}

import java.util.concurrent.*;
 
public class CallableWithPoolDemo {
 
    public static void main(String[] args) throws Exception {
        // 1. 创建一个固定大小的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);
 
        // 2. 提交 Callable 任务，线程池内部自动用 FutureTask 包装
        //    submit() 返回 Future 对象，用于获取结果
        Future<String> future = pool.submit(() -> {
            Thread.sleep(1000);                     // 模拟耗时操作
            return "Hello from " + Thread.currentThread().getName();
        });
 
        // 3. 获取结果（阻塞）
        String result = future.get();
        System.out.println(result);
 
        // 4. 关闭线程池（必须！否则 JVM 不会退出）
        pool.shutdown();
    }
}

public class Quiz {
    public static void main(String[] args) throws Exception {
        FutureTask<String> ft = new FutureTask<>(() -> {
            System.out.println("A");
            return "B";
        });
        new Thread(ft).start();
        new Thread(ft).start();
        System.out.println(ft.get());
    }
}

public class StartVsRun {
    public static void main(String[] args) {
        // 创建一个简单的线程，打印当前执行它的线程名
        Thread thread = new Thread(() -> {
            // 这行代码会告诉我们，到底是哪条线程在执行这个 lambda
            System.out.println("任务执行线程: " + Thread.currentThread().getName());
        }, "MyThread");
 
        // ========== 第一组：直接调用 run() ==========
        // 这里不会创建新线程，run() 在 main 线程中同步执行
        System.out.println("--- 直接调用 run() ---");
        thread.run();
        // 输出: 任务执行线程: main
        // 证明 run() 只是一个普通方法调用，执行线程仍然是 main
 
        // ========== 第二组：调用 start() ==========
        // 这里会创建一条新的操作系统线程，由新线程异步执行 run()
        System.out.println("--- 调用 start() ---");
        thread.start();
        // 输出: 任务执行线程: MyThread
        // 证明 start() 真正启动了一条名为 MyThread 的新线程
    }
}

public class SleepDemo {
    // 定义一个共享的锁对象
    private static final Object lock = new Object();
 
    public static void main(String[] args) {
        // 线程 A：获取锁后 sleep 3 秒
        Thread threadA = new Thread(() -> {
            synchronized (lock) {
                // 此时 threadA 持有 lock 的 monitor 锁
                System.out.println(Thread.currentThread().getName()
                        + " 获得锁, 开始 sleep...");
                try {
                    // sleep 3 秒，但不会释放 lock
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // 如果被中断，sleep 会抛出此异常
                    Thread.currentThread().interrupt(); // 恢复中断标志
                }
                System.out.println(Thread.currentThread().getName()
                        + " sleep 结束, 释放锁");
            }
            // 退出 synchronized 块，lock 才真正被释放
        }, "Thread-A");
 
        // 线程 B：尝试获取同一把锁
        Thread threadB = new Thread(() -> {
            synchronized (lock) {
                // 只有 threadA 释放锁之后，threadB 才能进入这里
                System.out.println(Thread.currentThread().getName()
                        + " 终于获得锁!");
            }
        }, "Thread-B");
 
        threadA.start();
        // 短暂等待，确保 threadA 先拿到锁
        try { Thread.sleep(100); } catch (InterruptedException ignored) {}
        threadB.start();
        // 观察输出：Thread-B 会在 Thread-A sleep 结束后才打印
    }
}

public class YieldDemo {
    public static void main(String[] args) {
        // 创建两个线程，观察 yield 对调度的影响
        Runnable task = () -> {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName()
                        + " - 第 " + i + " 次执行");
                if ("Thread-A".equals(Thread.currentThread().getName())) {
                    // Thread-A 每次循环都 yield，给 Thread-B 执行机会
                    Thread.yield();
                    // 注意：yield 之后 Thread-A 仍然可能立刻被调度回来
                }
            }
        };
 
        Thread threadA = new Thread(task, "Thread-A");
        Thread threadB = new Thread(task, "Thread-B");
 
        // 同时启动两个线程
        threadA.start();
        threadB.start();
        // 多次运行会发现：Thread-B 倾向于获得更多连续执行机会
        // 但结果不确定，因为 yield 只是 hint
    }
}

// Thread.join(long millis) 的简化版源码
public final synchronized void join(long millis) throws InterruptedException {
    long base = System.currentTimeMillis(); // 记录开始时间
    long now = 0;                           // 已等待时间
 
    if (millis == 0) {
        // millis 为 0 表示无限期等待
        while (isAlive()) {
            // 当目标线程还活着时，当前线程在 this（Thread 对象）上 wait
            // 注意：这里的 this 就是被 join 的那个 Thread 对象
            wait(0);
        }
    } else {
        // 有超时的版本
        while (isAlive()) {
            long delay = millis - now;      // 计算剩余等待时间
            if (delay <= 0) break;          // 超时，退出循环
            wait(delay);                    // 在 Thread 对象上等待
            now = System.currentTimeMillis() - base; // 更新已等待时间
        }
    }
    // 当目标线程终止时，JVM 会自动调用 this.notifyAll()
    // 从而唤醒所有在该 Thread 对象上 wait 的线程
}

public class JoinDemo {
    // 用数组存储每个子线程的计算结果
    private static final int[] results = new int[3];
 
    public static void main(String[] args) throws InterruptedException {
        // 创建 3 个子线程，每个负责计算一部分
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000); // 模拟耗时计算
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            results[0] = 10; // 线程 1 的计算结果
            System.out.println("t1 计算完成: " + results[0]);
        }, "t1");
 
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000); // 模拟更长的耗时计算
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            results[1] = 20; // 线程 2 的计算结果
            System.out.println("t2 计算完成: " + results[1]);
        }, "t2");
 
        Thread t3 = new Thread(() -> {
            try {
                Thread.sleep(1500); // 模拟耗时计算
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            results[2] = 30; // 线程 3 的计算结果
            System.out.println("t3 计算完成: " + results[2]);
        }, "t3");
 
        // 启动所有子线程
        t1.start();
        t2.start();
        t3.start();
 
        // 主线程依次等待每个子线程完成
        t1.join(); // 阻塞直到 t1 终止
        t2.join(); // 阻塞直到 t2 终止（t2 最慢，约 2 秒）
        t3.join(); // t3 此时大概率已经结束，join 立即返回
 
        // 所有子线程都已完成，安全地汇总结果
        int total = results[0] + results[1] + results[2];
        System.out.println("汇总结果: " + total); // 输出: 汇总结果: 60
    }
}

public class Quiz {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            System.out.println("A");
            Thread.yield();
            System.out.println("B");
        });
 
        t.run();
        t.start();
        t.join();
        System.out.println("C");
    }
}

// Thread 类源码中的三个优先级常量
public static final int MIN_PRIORITY = 1;   // 最低优先级
public static final int NORM_PRIORITY = 5;  // 默认优先级（新线程继承父线程优先级，主线程为5）
public static final int MAX_PRIORITY = 10;  // 最高优先级

// Thread 初始化时的优先级继承逻辑（OpenJDK 源码简化）
Thread parent = currentThread();           // 获取当前正在执行的线程（即父线程）
this.priority = parent.getPriority();      // 子线程继承父线程的优先级

public class PriorityDemo {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 线程体：打印自身优先级
            System.out.println("当前线程优先级: " + Thread.currentThread().getPriority());
        }, "worker");
 
        // 设置优先级为 8（高于默认的 5）
        t.setPriority(8);
 
        // 获取优先级，验证设置是否生效
        System.out.println("设置后优先级: " + t.getPriority()); // 输出 8
 
        t.start();
    }
}

// setPriority 源码中的边界检查
public final void setPriority(int newPriority) {
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();  // 超出 1-10 范围直接抛异常
    }
    // ... 后续还会受到线程组（ThreadGroup）最大优先级的限制
}

public class ThreadGroupPriorityCap {
    public static void main(String[] args) {
        // 创建一个最大优先级为 7 的线程组
        ThreadGroup group = new ThreadGroup("capped-group");
        group.setMaxPriority(7);                          // 线程组上限设为 7
 
        Thread t = new Thread(group, () -> {
            // 打印实际生效的优先级
            System.out.println("实际优先级: " + Thread.currentThread().getPriority());
        }, "capped-thread");
 
        t.setPriority(10);                                // 尝试设为 10
        System.out.println("getPriority: " + t.getPriority()); // 输出 7，被线程组截断
        t.start();
    }
}

┌─────────────────────────────────────────────────────────────────┐
│              Java Priority → OS Priority 映射示意               │
├──────────────┬──────────────────────┬───────────────────────────┤
│ Java (1-10)  │   Linux (nice值)     │   Windows (优先级级别)     │
├──────────────┼──────────────────────┼───────────────────────────┤
│     1        │    nice = 4          │   THREAD_PRIORITY_LOWEST  │
│     2        │    nice = 3          │   THREAD_PRIORITY_LOWEST  │
│     3        │    nice = 2          │   THREAD_PRIORITY_BELOW.. │
│     4        │    nice = 1          │   THREAD_PRIORITY_BELOW.. │
│     5        │    nice = 0          │   THREAD_PRIORITY_NORMAL  │
│     6        │    nice = -1         │   THREAD_PRIORITY_ABOVE.. │
│     7        │    nice = -2         │   THREAD_PRIORITY_ABOVE.. │
│     8        │    nice = -3         │   THREAD_PRIORITY_HIGHEST │
│     9        │    nice = -4         │   THREAD_PRIORITY_HIGHEST │
│    10        │    nice = -5         │   THREAD_PRIORITY_CRITICAL│
└──────────────┴──────────────────────┴───────────────────────────┘
  注意：Linux 上多个 Java 优先级可能映射到同一个 nice 值，
  导致优先级差异在 Linux 上几乎无法体现。

public class PriorityUnreliableDemo {
    // 用于统计每个线程的执行次数
    private static volatile boolean running = true;
 
    public static void main(String[] args) throws InterruptedException {
        // 创建一个低优先级线程
        Thread low = new Thread(() -> {
            long count = 0;                          // 计数器：记录循环执行次数
            while (running) {                        // 持续运行直到标志位变为 false
                count++;                             // 每次循环计数 +1
            }
            System.out.println("LOW  (priority=1) 执行次数: " + count);
        }, "low-priority");
 
        // 创建一个高优先级线程
        Thread high = new Thread(() -> {
            long count = 0;                          // 计数器
            while (running) {                        // 同样持续运行
                count++;                             // 计数 +1
            }
            System.out.println("HIGH (priority=10) 执行次数: " + count);
        }, "high-priority");
 
        low.setPriority(Thread.MIN_PRIORITY);        // 设置为最低优先级 1
        high.setPriority(Thread.MAX_PRIORITY);       // 设置为最高优先级 10
 
        low.start();                                 // 启动低优先级线程
        high.start();                                // 启动高优先级线程
 
        Thread.sleep(3000);                          // 主线程等待 3 秒
        running = false;                             // 通知两个线程停止
 
        low.join();                                  // 等待低优先级线程结束
        high.join();                                 // 等待高优先级线程结束
    }
}

// 场景：GC 辅助线程、后台日志刷盘等低优先级任务
Thread backgroundFlusher = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        flushLogBuffer();                            // 刷新日志缓冲区
        try {
            Thread.sleep(1000);                      // 每秒刷一次
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();       // 恢复中断标志
            break;                                   // 退出循环
        }
    }
}, "log-flusher");
 
backgroundFlusher.setPriority(Thread.MIN_PRIORITY);  // 后台任务设为低优先级
backgroundFlusher.setDaemon(true);                    // 同时设为守护线程
backgroundFlusher.start();

public class DaemonThreadBasic {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个线程，模拟后台持续运行的任务
        Thread daemonThread = new Thread(() -> {
            // 守护线程内部执行一个"无限循环"任务
            while (true) {
                try {
                    // 每隔 500ms 打印一次心跳信息
                    Thread.sleep(500);
                    // 如果这是守护线程，当所有用户线程结束后，这行可能永远不会再执行
                    System.out.println("[Daemon] 心跳检测中... " + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    // sleep 被中断时的处理
                    System.out.println("[Daemon] 被中断，退出心跳循环");
                    break; // 中断后退出循环
                }
            }
        }, "heartbeat-daemon"); // 给线程起一个有意义的名字，方便调试
 
        // 【关键】必须在 start() 之前调用 setDaemon(true)
        daemonThread.setDaemon(true);
 
        // 启动守护线程
        daemonThread.start();
 
        // 主线程（用户线程）只工作 2 秒
        System.out.println("[Main] 主线程开始工作...");
        Thread.sleep(2000); // 主线程休眠 2 秒，模拟业务处理
        System.out.println("[Main] 主线程工作结束，即将退出");
 
        // 主线程结束后，如果没有其他用户线程存活，JVM 将退出
        // 守护线程 daemonThread 会被强制终止，不会继续打印心跳
    }
}

public class DaemonAfterStartError {
    public static void main(String[] args) {
        // 创建一个普通线程
        Thread thread = new Thread(() -> {
            // 线程体：简单打印一条消息
            System.out.println("线程正在运行...");
        });
 
        // 先启动线程
        thread.start();
 
        try {
            // 【错误】在 start() 之后调用 setDaemon()
            // 这里会抛出 IllegalThreadStateException
            thread.setDaemon(true);
        } catch (IllegalThreadStateException e) {
            // 捕获异常并打印错误信息
            System.out.println("异常捕获: " + e.getClass().getSimpleName());
            System.out.println("原因: 线程已经启动，无法再修改 daemon 状态");
        }
    }
}

// Thread.java 构造方法内部（简化）
private Thread(ThreadGroup g, Runnable target, String name, long stackSize) {
    // 获取当前正在执行构造方法的线程，即"父线程"
    Thread parent = currentThread();
 
    // 新线程继承父线程的 daemon 属性
    // 如果父线程是守护线程，子线程默认也是守护线程
    this.daemon = parent.isDaemon();
 
    // 新线程继承父线程的优先级
    this.priority = parent.getPriority();
 
    // ... 其他初始化逻辑
}

public class DaemonInheritance {
    public static void main(String[] args) throws InterruptedException {
        // 创建一个守护线程作为"父线程"
        Thread parentDaemon = new Thread(() -> {
            // 在守护线程内部创建一个子线程
            Thread child = new Thread(() -> {
                // 子线程打印自己的 daemon 状态
                System.out.println("[Child] 是否为守护线程: " + Thread.currentThread().isDaemon());
                // 输出: true —— 继承了父线程的 daemon 属性
            }, "child-thread");
 
            // 注意：这里没有调用 child.setDaemon()，完全依赖继承
            child.start(); // 启动子线程
 
            try {
                // 等待子线程执行完毕
                child.join();
            } catch (InterruptedException e) {
                // join 被中断时的处理
                Thread.currentThread().interrupt();
            }
        }, "parent-daemon");
 
        // 将父线程设置为守护线程
        parentDaemon.setDaemon(true);
        // 启动父守护线程
        parentDaemon.start();
 
        // 主线程等待足够时间让守护线程内部逻辑执行完
        Thread.sleep(1000);
        // 打印父线程的 daemon 状态作为对照
        System.out.println("[Parent] 是否为守护线程: " + parentDaemon.isDaemon());
    }
}

public class JvmExitCondition {
    public static void main(String[] args) throws InterruptedException {
        // === 创建守护线程：模拟后台日志刷盘服务 ===
        Thread logFlusher = new Thread(() -> {
            int count = 0; // 记录刷盘次数
            while (true) {
                try {
                    // 每秒执行一次"刷盘"操作
                    Thread.sleep(1000);
                    count++; // 递增计数器
                    System.out.println("[LogFlusher-Daemon] 第 " + count + " 次刷盘...");
                } catch (InterruptedException e) {
                    // 如果 sleep 被中断，退出循环
                    break;
                }
            }
            // 【注意】这行代码大概率不会被执行！
            // 因为守护线程是被 JVM 强制终止的，不会走到循环外部
            System.out.println("[LogFlusher-Daemon] 优雅退出（这行几乎不会打印）");
        }, "log-flusher");
 
        // 设置为守护线程
        logFlusher.setDaemon(true);
        // 启动守护线程
        logFlusher.start();
 
        // === 创建用户线程 A：模拟业务处理 ===
        Thread workerA = new Thread(() -> {
            try {
                System.out.println("[WorkerA] 开始处理业务，预计 3 秒...");
                // 模拟 3 秒的业务处理
                Thread.sleep(3000);
                System.out.println("[WorkerA] 业务处理完成");
            } catch (InterruptedException e) {
                // 处理中断
                Thread.currentThread().interrupt();
            }
        }, "worker-A");
        // workerA 是用户线程（默认），不需要 setDaemon
 
        // === 创建用户线程 B：模拟另一个业务处理 ===
        Thread workerB = new Thread(() -> {
            try {
                System.out.println("[WorkerB] 开始处理业务，预计 5 秒...");
                // 模拟 5 秒的业务处理
                Thread.sleep(5000);
                System.out.println("[WorkerB] 业务处理完成");
            } catch (InterruptedException e) {
                // 处理中断
                Thread.currentThread().interrupt();
            }
        }, "worker-B");
 
        // 启动所有线程
        workerA.start();
        workerB.start();
 
        // 主线程自身也是用户线程，这里让它立即结束
        System.out.println("[Main] 主线程结束");
 
        // 此时存活的用户线程：workerA, workerB
        // 存活的守护线程：logFlusher
        // JVM 不会退出，因为还有用户线程存活
 
        // 约 3 秒后 workerA 结束 → JVM 检查 → workerB 还在 → 继续运行
        // 约 5 秒后 workerB 结束 → JVM 检查 → 没有用户线程了 → JVM 退出
        // logFlusher 守护线程被强制终止，大约只打印了 4-5 次刷盘日志
    }
}

public class DaemonFinallyTrap {
    public static void main(String[] args) throws InterruptedException {
        // 创建守护线程，内部包含 try-finally 结构
        Thread daemon = new Thread(() -> {
            try {
                System.out.println("[Daemon] 开始执行任务...");
                // 模拟一个长时间运行的任务
                while (true) {
                    // 持续运行，等待被 JVM 终止
                    Thread.sleep(500);
                    System.out.println("[Daemon] 工作中...");
                }
            } catch (InterruptedException e) {
                // sleep 被中断时进入这里
                System.out.println("[Daemon] 被中断");
            } finally {
                // 【危险】这个 finally 块在守护线程被 JVM 强制终止时，不保证执行！
                // 如果你在这里做资源清理（关闭文件、释放连接），可能永远不会执行
                System.out.println("[Daemon] finally 块执行 —— 清理资源");
                // 假设这里有: connection.close(), fileStream.flush() 等操作
                // 这些操作可能永远不会被执行！
            }
        }, "risky-daemon");
 
        // 设置为守护线程
        daemon.setDaemon(true);
        // 启动
        daemon.start();
 
        // 主线程只存活 1.5 秒
        Thread.sleep(1500);
        System.out.println("[Main] 主线程结束，JVM 即将退出...");
        // 主线程结束 → 没有其他用户线程 → JVM 退出
        // daemon 线程的 finally 块大概率不会执行
    }
}

public class ShutdownHookDemo {
    public static void main(String[] args) throws InterruptedException {
        // 注册一个 Shutdown Hook —— JVM 关闭时会执行这个线程
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            // 这个线程会在 JVM 关闭流程中被启动并执行
            System.out.println("[ShutdownHook] JVM 正在关闭，执行清理操作...");
            System.out.println("[ShutdownHook] 关闭数据库连接...");
            System.out.println("[ShutdownHook] 刷新日志缓冲区...");
            System.out.println("[ShutdownHook] 清理完成");
        }, "my-shutdown-hook"));
 
        // 创建守护线程
        Thread daemon = new Thread(() -> {
            while (true) {
                try {
                    Thread.sleep(500); // 每 500ms 执行一次
                    System.out.println("[Daemon] 后台服务运行中...");
                } catch (InterruptedException e) {
                    break; // 中断后退出
                }
            }
        }, "background-service");
 
        daemon.setDaemon(true); // 标记为守护线程
        daemon.start(); // 启动守护线程
 
        // 主线程工作 2 秒后结束
        Thread.sleep(2000);
        System.out.println("[Main] 主线程结束");
 
        // JVM 关闭流程：
        // 1. 所有用户线程结束
        // 2. JVM 启动 Shutdown Hook（用户线程，会被执行）
        // 3. Shutdown Hook 执行完毕
        // 4. 守护线程被强制终止
        // 5. JVM 进程退出
    }
}

public class DaemonQuiz {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            Thread t2 = new Thread(() -> {
                try {
                    Thread.sleep(5000);
                    System.out.println("T2 完成");
                } catch (InterruptedException e) {
                    System.out.println("T2 被中断");
                }
            });
            t2.start();
            System.out.println("T1 完成, T2.isDaemon=" + t2.isDaemon());
        });
        t1.setDaemon(true);
        t1.start();
        Thread.sleep(1000);
        System.out.println("Main 结束");
    }
}

public class CrossThreadExceptionDemo {
    public static void main(String[] args) {
        // 在主线程中用 try-catch 包裹子线程的启动
        try {
            // 创建一个会抛出异常的子线程
            Thread t = new Thread(() -> {
                // 这行代码在子线程的调用栈中执行
                throw new RuntimeException("子线程爆炸了！");
            });
            // start() 本身只是通知 OS 创建线程，立即返回
            t.start();
        } catch (Exception e) {
            // 这里永远不会捕获到子线程的异常
            System.out.println("主线程捕获到异常: " + e.getMessage());
        }
 
        // 主线程继续运行，完全不知道子线程已经死了
        System.out.println("主线程正常结束");
    }
}

// Thread 类内部定义的函数式接口
@FunctionalInterface
public interface UncaughtExceptionHandler {
    /**
     * 当线程因未捕获异常即将终止时，JVM 调用此方法
     * @param t  即将终止的线程对象
     * @param e  导致线程终止的未捕获异常
     */
    void uncaughtException(Thread t, Throwable e);
}

public class HandlerPriorityDemo {
    public static void main(String[] args) {
 
        // ① 全局默认处理器 —— 对所有线程生效（优先级最低）
        // 通过 Thread 类的静态方法设置
        Thread.setDefaultUncaughtExceptionHandler((t, e) -> {
            // 当线程没有设置专属处理器，也没有线程组处理器时，走这里
            System.out.println("[全局默认] 线程 " + t.getName() + " 异常: " + e.getMessage());
        });
 
        // ② 线程实例专属处理器 —— 只对当前线程对象生效（优先级最高）
        Thread worker = new Thread(() -> {
            // 模拟业务异常
            throw new RuntimeException("任务执行失败");
        }, "Worker-1");
        // 通过线程实例的方法设置
        worker.setUncaughtExceptionHandler((t, e) -> {
            // 这个处理器只对 worker 这一个线程对象有效
            System.out.println("[实例专属] 线程 " + t.getName() + " 异常: " + e.getMessage());
        });
 
        // ③ 线程组处理器 —— 对组内所有线程生效（优先级居中）
        // 需要继承 ThreadGroup 并重写 uncaughtException 方法
        ThreadGroup group = new ThreadGroup("MyGroup") {
            @Override
            public void uncaughtException(Thread t, Throwable e) {
                // 组内线程如果没有设置实例专属处理器，走这里
                System.out.println("[线程组] 线程 " + t.getName() + " 异常: " + e.getMessage());
            }
        };
        // 创建线程时指定所属线程组
        Thread groupWorker = new Thread(group, () -> {
            throw new RuntimeException("组内任务失败");
        }, "GroupWorker-1");
 
        worker.start();       // 触发 ② 实例专属处理器
        groupWorker.start();  // 触发 ③ 线程组处理器
    }
}

import java.util.logging.Level;
import java.util.logging.Logger;
 
public class GlobalExceptionHandlerSetup {
 
    // 使用 JDK 自带的 Logger（生产中通常用 SLF4J + Logback）
    private static final Logger logger = Logger.getLogger("GlobalExceptionHandler");
 
    public static void main(String[] args) {
        // 在应用启动的最早阶段设置全局兜底处理器
        setupGlobalExceptionHandler();
 
        // 模拟业务线程
        Thread bizThread = new Thread(() -> {
            // 模拟某个深层调用抛出了未预期的异常
            processOrder("ORDER-12345");
        }, "BizThread-Order");
 
        bizThread.start();
    }
 
    /**
     * 设置全局未捕获异常处理器
     * 建议在 main 方法的第一行调用
     */
    private static void setupGlobalExceptionHandler() {
        Thread.setDefaultUncaughtExceptionHandler((thread, throwable) -> {
            // 1. 记录详细日志（线程名、异常类型、完整堆栈）
            logger.log(Level.SEVERE,
                    String.format("线程 [%s] 因未捕获异常终止 | 异常类型: %s | 消息: %s",
                            thread.getName(),
                            throwable.getClass().getName(),
                            throwable.getMessage()),
                    throwable  // 传入 throwable 对象，Logger 会自动记录完整堆栈
            );
 
            // 2. 根据异常类型决定后续动作
            if (throwable instanceof OutOfMemoryError) {
                // OOM 通常意味着 JVM 状态已不可靠，记录后快速退出
                logger.severe("检测到 OOM，准备终止 JVM...");
                // 给日志系统一点时间刷盘
                Runtime.getRuntime().halt(1);
            }
 
            // 3. 对于普通业务异常，可以触发告警（邮件、钉钉、Prometheus 指标等）
            //    alertService.sendAlert("线程异常终止", thread.getName(), throwable);
        });
    }
 
    private static void processOrder(String orderId) {
        // 模拟业务逻辑中的意外异常
        throw new IllegalStateException("订单 " + orderId + " 处理失败：库存不足");
    }
}

import java.util.concurrent.*;
 
public class ThreadPoolExceptionDemo {
    public static void main(String[] args) throws Exception {
 
        // 创建线程池时，通过 ThreadFactory 为池中每个线程设置异常处理器
        ExecutorService pool = Executors.newFixedThreadPool(2, r -> {
            Thread t = new Thread(r);
            // 为线程池中的线程设置 UncaughtExceptionHandler
            t.setUncaughtExceptionHandler((thread, ex) -> {
                System.out.println("[Handler] 线程 " + thread.getName()
                        + " 捕获异常: " + ex.getMessage());
            });
            return t;
        });
 
        // ===== 方式一：execute() 提交 =====
        // execute() 直接在工作线程中运行任务
        // 如果任务抛出异常，工作线程终止，UncaughtExceptionHandler 会被触发
        pool.execute(() -> {
            throw new RuntimeException("execute 提交的任务异常");
        });
 
        // 等待一下，让上面的任务执行完
        Thread.sleep(500);
        System.out.println("--- 分隔线 ---");
 
        // ===== 方式二：submit() 提交 =====
        // submit() 返回 Future，异常被封装在 Future 内部
        // 工作线程不会终止，UncaughtExceptionHandler 不会被触发！
        Future<?> future = pool.submit(() -> {
            throw new RuntimeException("submit 提交的任务异常");
        });
 
        try {
            // 异常在调用 future.get() 时才会以 ExecutionException 的形式抛出
            future.get();
        } catch (ExecutionException e) {
            // getCause() 获取原始异常
            System.out.println("[Future.get()] 捕获异常: " + e.getCause().getMessage());
        }
 
        pool.shutdown();
    }
}

pool.execute(() -> {
    try {
        // 业务逻辑
        riskyOperation();
    } catch (Exception e) {
        // 在任务内部处理异常：记录日志、上报指标等
        logger.error("任务执行异常", e);
    }
});

// ThreadGroup 的默认实现（JDK 源码简化版）
public void uncaughtException(Thread t, Throwable e) {
    // 1. 如果有父线程组，委托给父线程组处理
    if (parent != null) {
        parent.uncaughtException(t, e);
    } else {
        // 2. 没有父线程组，检查全局默认处理器
        Thread.UncaughtExceptionHandler defaultHandler =
                Thread.getDefaultUncaughtExceptionHandler();
        if (defaultHandler != null) {
            // 调用全局默认处理器
            defaultHandler.uncaughtException(t, e);
        } else {
            // 3. 什么处理器都没有，打印到 System.err
            // 注意：ThreadDeath 异常会被静默忽略（stop() 遗留行为）
            if (!(e instanceof ThreadDeath)) {
                System.err.print("Exception in thread \""
                        + t.getName() + "\" ");
                e.printStackTrace(System.err);
            }
        }
    }
}

public class QuizUncaughtHandler {
    public static void main(String[] args) throws Exception {
        Thread.setDefaultUncaughtExceptionHandler((t, e) ->
                System.out.println("DEFAULT: " + e.getMessage()));
 
        ExecutorService pool = Executors.newSingleThreadExecutor();
 
        pool.submit(() -> { throw new RuntimeException("boom"); });
 
        Thread t = new Thread(() -> { throw new RuntimeException("bang"); });
        t.start();
 
        Thread.sleep(1000);
        pool.shutdown();
    }
}

public class ThreadQuiz {
    public static void main(String[] args) {
        // 创建一个线程，run() 方法中打印当前线程名称
        Thread t = new Thread(() -> {
            System.out.println("A-" + Thread.currentThread().getName());
        }, "Worker");
 
        // 直接调用 run()，而非 start()
        t.run();
        // 打印主线程名称
        System.out.println("B-" + Thread.currentThread().getName());
    }
}