【Java】Thread

Thread 类

Java中的Thread类是java.lang包的核心类，用于实现多线程编程，允许程序并发执行多个任务，提升性能和资源利用率。以下是其核心概念与用法的系统梳理：

⚙️ 线程的创建方式

继承Thread类

自定义类继承Thread，重写run()定义任务逻辑。

示例：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running");
    }
}
// 启动线程
new MyThread().start(); // 调用start()触发run()执行

实现Runnable接口（更推荐）

实现Runnable接口，将任务对象传入Thread构造器。

优势：避免单继承限制，任务与线程解耦。

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Task executed");
    }
}
new Thread(new MyRunnable()).start();

🔧 Thread类的核心方法

方法	作用
`start()`	启动线程，JVM自动调用`run()`，仅能调用一次
`run()`	线程任务逻辑入口，需重写或通过`Runnable`传入
`sleep(long millis)`	暂停当前线程指定毫秒，不释放锁，需处理`InterruptedException`
`join()` / `join(millis)`	等待线程终止（或超时），用于线程同步
`interrupt()`	中断线程（设置标志位），需在`run()`中检查`isInterrupted()`响应中断
`yield()`	提示调度器让出CPU，但不保证立即切换
`setDaemon(true)`	设置为守护线程（JVM在所有非守护线程结束时退出）

📌 线程属性与状态

关键属性
- ID：唯一标识（getId()）
- 名称：调试用（getName()/setName()）
- 优先级：1~10（默认5），高优先级仅增加调度概率，不保证优先
- 是否存活：isAlive()检测run()是否结束
线程状态（getState()）
- NEW：创建未启动
- RUNNABLE：可运行（包括就绪和运行中）
- BLOCKED：等待锁
- WAITING：无限期等待（如join()）
- TIMED_WAITING：超时等待（如sleep()）
- TERMINATED：执行完毕

⚠️ 高级特性与注意事项

线程中断机制
- 通过interrupt()设置中断标志，线程需在run()中检查isInterrupted()并退出循环或捕获InterruptedException。
- 示例：
```
while (!Thread.currentThread().isInterrupted()) {
    // 执行任务
}
```
线程同步
- 多线程访问共享资源需使用synchronized关键字或Lock接口，避免竞态条件。
线程局部变量（ThreadLocal）
- 为每个线程创建独立变量副本，避免共享冲突（如数据库连接）。
资源释放
- 线程终止后，其占用的内存资源（如堆栈）由JVM自动回收，但需确保无资源泄漏（如未关闭的文件流）。

💎 实践建议

优先选择Runnable接口：提升代码灵活性，符合组合优于继承原则。
避免直接调用run()：否则变为普通方法调用，失去并发性。
守护线程慎用：用于辅助任务（如心跳检测），避免影响JVM退出。
中断优于强制终止：弃用suspend()/resume()/stop()（易导致死锁）。

总结

Java的Thread类是多线程编程的基石，通过start()、状态管理、同步机制等实现并发控制。深入理解其生命周期、中断机制及同步策略，是构建高效安全并发应用的关键。实践中应结合Runnable、线程池（如ExecutorService）等高级工具提升可维护性。

`Thread` 类默认实现

Java中的Thread类默认实现包含多个关键行为，这些行为在未显式重写或指定时自动生效。以下是其核心默认实现的系统梳理：

⚙️ 默认构造方法：`Thread()`

线程名称
- 默认生成格式为"Thread-" + 自增数字（如Thread-0、Thread-1），通过静态计数器nextThreadNum()实现。
- 可通过Thread.currentThread().getName()获取。
任务逻辑（run方法）
- 默认run()方法不执行任何操作。
- 若未传入Runnable任务对象或未重写run()，调用start()后线程会启动但无实际逻辑执行。
- 源码实现：
```
public void run() {
    if (target != null) { // target为传入的Runnable对象
        target.run();
    }
}
```

🧩 线程组（ThreadGroup）

默认分配规则：
- 若未显式指定线程组，新线程会继承父线程的线程组（如主线程创建的子线程，其线程组与主线程相同）。
- 通过ThreadGroup parentGroup = parent.getThreadGroup()实现（parent为创建该线程的当前线程）。
安全性：线程组为空时，会通过SecurityManager检查权限。

📛 线程名称生成机制

自增规则：
- 静态变量threadInitNumber记录全局线程数量，每次构造新线程时自增。
- 示例：
```
new Thread().start(); // 线程名：Thread-0
new Thread().start(); // 线程名：Thread-1
```

⚖️ 守护状态与优先级继承

守护线程（Daemon）
- 默认非守护线程（daemon = false）。
- 守护线程需显式调用setDaemon(true)，且必须在start()前设置。
优先级
- 默认继承父线程优先级（通常主线程为NORM_PRIORITY=5）。
- 可通过setPriority()调整（1~10），但优先级仅作调度器参考，不保证执行顺序。

🔍 线程栈大小（stackSize）

默认值为0，表示由JVM自动分配栈大小（通常取决于操作系统和JVM参数）。
可通过构造方法Thread(ThreadGroup, Runnable, String, long)显式指定栈大小（单位：字节），但平台兼容性较差。

⚠️ 默认实现的实践意义与风险

常见误区
- 直接调用run()而非start()：导致任务在当前线程同步执行，失去多线程意义。
- 未重写run()或传入Runnable：线程启动后无操作，易被忽略。
设计意图
- 解耦任务与线程：默认run()留空，强制开发者通过Runnable或重写方式明确任务逻辑，符合组合优于继承原则。
- 安全继承：线程组、优先级等属性的自动继承，减少重复配置，确保线程环境一致性。

💎 总结

Thread类的默认实现聚焦于基础框架搭建与安全约束：

通过空run()方法强制任务显式定义，避免隐式行为；
通过名称自增、线程组继承等机制减少配置成本；
依赖父线程属性（优先级、守护状态）确保环境一致性。 开发者需主动注入任务逻辑（Runnable或重写run()）并理解默认行为，才能有效利用多线程能力。

run()

源码

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }

Runnable

Thread 类实现 Runnable 接口是 Java 多线程设计的核心思想之一，其背后蕴含了职责分离、灵活性和框架兼容性等多重考量。以下从设计哲学、技术实现和实际应用三个维度详细解析原因：

🔧 设计哲学：职责分离与组合优于继承

统一任务执行标准 Runnable 接口定义了线程任务的唯一方法 run()，而 Thread 作为线程的载体，通过实现 Runnable 接口，自身也成为一个可执行的任务。这种设计使得：
- 任务与线程解耦：Runnable 仅描述任务逻辑，Thread 负责线程的创建、调度和管理。
- 灵活组合：用户可通过继承 Thread 重写 run()（自身即任务），或向 Thread 传入外部 Runnable 对象（委托执行任务），实现任务逻辑的多样化封装1,5。
规避单继承限制 Java 不支持多继承，若 Thread 未实现 Runnable，则通过继承 Thread 定义任务的方式会永久占用类的继承权。而实现 Runnable 接口后：
- 开发者可选择更灵活的 组合模式（传入 Runnable 任务），避免因继承 Thread 导致无法继承其他业务类的问题4,7。

⚙️ 技术实现：委托机制与默认逻辑

源码中的委托模式 在 Thread 类的源码中，通过 target 字段支持外部任务：
```
public class Thread implements Runnable {
    private Runnable target; // 存储外部任务
    @Override
    public void run() {
        if (target != null) {
            target.run(); // 委托执行外部任务
        }
    }
}
```
- 默认行为：直接继承 Thread 时，需重写 run() 方法（覆盖默认逻辑）。
- 外部任务：通过构造函数传入 Runnable 对象时，Thread.run() 会调用其 target.run()3,5。

支持两种任务定义方式

方式1（继承 Thread）：

class MyThread extends Thread {
    @Override public void run() { /* 自定义逻辑 */ }
}
new MyThread().start();

方式2（组合 Runnable）：

class MyTask implements Runnable {
    @Override public void run() { /* 自定义逻辑 */ }
}
new Thread(new MyTask()).start();

两种方式最终均通过 Thread.run() 统一执行，体现了接口的适配性4,8。

🚀 实际应用：灵活性与生态兼容

任务复用与线程池集成
- 资源共享：同一个 Runnable 任务可被多个 Thread 实例执行（如线程池中的任务队列），避免重复创建任务对象4,7。
- 线程池兼容：Java 并发框架（如

     ExecutorService
     ```
     ）直接接受

 Runnable
 ```

任务，与

     Thread
     ```
解耦：
     ```
     ExecutorService pool = Executors.newFixedThreadPool(2);
     pool.submit(() -> System.out.println("Runnable任务")); // 无需绑定Thread实例
     ```
2. **函数式编程支持**
   `Runnable` 是函数式接口（仅有一个抽象方法），可直接用 Lambda 表达式简化代码：

new Thread(() -> System.out.println(“Lambda任务”)).start();

若 `Thread` 未实现 `Runnable`，此写法将无法成立[4,5](@ref)。
3. **框架设计的扩展性**
- **Callable/Future 兼容**：`Callable` 作为 `Runnable` 的增强版（支持返回值），通过 `FutureTask` 适配 `Runnable` 接口，最终仍由 `Thread` 执行。
- **虚拟线程支持**：Java 21 的虚拟线程（`Thread.startVirtualThread()`）直接接受 `Runnable` 任务，延续了统一的任务抽象[5,8](@ref)。


------
### ⚖️ **继承Thread vs 实现Runnable的对比**

| **维度**       | **继承 Thread**              | **实现 Runnable**                  |
| -------------- | ---------------------------- | ---------------------------------- |
| **任务定义**   | 重写 `run()`，任务与线程绑定 | 实现 `run()`，任务可独立于线程存在 |
| **继承灵活性** | 占用继承权，无法继承其他类   | 可继承其他类，无限制               |
| **任务复用**   | 一个线程实例只能执行自身任务 | 同一任务可被多个线程执行           |
| **函数式支持** | 不支持 Lambda                | 支持 Lambda 表达式                 |
| **线程池兼容** | 需包装成 `Runnable` 提交     | 直接提交任务对象                   |
> 💡 **设计启示**：`Thread` 实现 `Runnable` 本质是 **“自身即任务”** 与 **“委托外部任务”** 的辩证统一，既保留了传统用法，又为现代并发框架铺平道路。


------
### 💎 **总结**

Thread 实现 `Runnable` 接口的核心价值在于：
1. **统一性**：通过 `run()` 方法统一所有线程任务的执行入口。
2. **解耦性**：分离线程控制（`Thread`）与任务逻辑（`Runnable`），支持组合优于继承。
3. **扩展性**：为线程池、函数式编程、虚拟线程等高级特性提供底层兼容。
这一设计是 Java 并发模型的基石，深刻体现了 **“简单性不应牺牲灵活性”** 的工程哲学[1,5,7](@ref)。实际开发中，**优先使用 `Runnable`**（或 `Callable`）配合线程池，已成为现代 Java 并发的黄金实践。
## Join()

在Java中，`Thread.join()`方法等待的**不是显式的信号量或事件**，而是**目标线程终止（即线程执行结束）的状态变化**。其底层实现依赖于JVM内部的线程状态管理与同步机制，具体原理如下：


------
### ⚙️ **等待的目标：线程终止状态**

`join()`的核心作用是**阻塞当前线程，直到目标线程（调用`join`方法的线程实例）结束运行**。例如：
```java
Thread t = new Thread(() -> { /* 任务逻辑 */ });
t.start();
t.join(); // 当前线程在此阻塞，直到t线程执行完毕

这里等待的“信号”实质是目标线程从RUNNABLE状态转变为TERMINATED状态。

🔧 底层实现：基于锁与等待队列

join()的阻塞和唤醒依赖Java的对象监视器锁（Monitor） 和 wait/notify机制，具体流程如下：

（1）阻塞当前线程

当调用t.join()时，当前线程（如主线程）会获取目标线程对象t的锁（synchronized修饰的方法）。
在锁内部，通过
```
while (t.isAlive())
```
循环检查目标线程是否存活：
- 若目标线程存活，则调用t.wait(0)，释放锁并进入等待状态（WAITING或TIMED_WAITING）。

（2）唤醒机制

当目标线程t执行完毕（进入TERMINATED状态）时，JVM在底层自动调用notifyAll()，唤醒所有在t对象上等待的线程。

这一过程在JVM源码中由

ensure_join()

函数触发（参考HotSpot的

thread.cpp

）：

void JavaThread::exit() {
  ensure_join(this); // 唤醒等待该线程结束的线程
}
static void ensure_join(JavaThread* thread) {
  lock.notify_all(thread); // 调用notifyAll唤醒等待者
}

关键点：开发者无需手动调用notify()，JVM在线程结束时自动处理唤醒逻辑。

⚠️ 中断处理

若等待过程中当前线程被中断（调用interrupt()）：

join()会抛出InterruptedException，并清除中断标志位；
此时需捕获异常并处理中断（如退出任务或重置状态）。

try {
    t.join();
} catch (InterruptedException e) {
    // 处理中断：恢复标志位或终止任务
    Thread.currentThread().interrupt(); 
}

🔄 超时控制

join(long millis)允许设置最大等待时间：

若超时后目标线程仍未结束，当前线程会自动唤醒并继续执行；
实现通过wait(delay)循环检查时间，避免永久阻塞。

💎 总结：等待的“信号”是什么？

物理层面：线程对象t的锁状态变化（wait() → notifyAll()）；
逻辑层面：目标线程从存活（isAlive() == true）到终止（TERMINATED）的状态切换；
触发方：JVM在目标线程结束时自动触发唤醒操作，无需开发者干预。通过这一机制，join()实现了线程间的顺序控制，常用于主线程等待子线程完成后再进行结果汇总或资源回收。

Interrupt() & yield()

在Java中，interrupt()和yield()方法的调用范围和行为有显著区别，具体分析如下：

⚙️ `interrupt()`方法的调用范围

线程内调用：线程可以在自身内部调用interrupt()，例如在run()方法中通过Thread.currentThread().interrupt()中断自己。这种方式通常用于在捕获InterruptedException后重新设置中断标志（例如在catch块中）。
线程外调用：允许在其他线程中调用目标线程的
```
interrupt()
```
方法。例如，主线程可以通过
```
thread.interrupt()
```
中断子线程。但需注意：
- 若目标线程处于运行状态，仅设置中断标志位，需线程内部主动检查（如isInterrupted()）才能响应中断。
- 若目标线程处于阻塞状态（如sleep()、wait()、join()），会立即抛出InterruptedException并清除中断标志。
- 权限要求：调用方需持有目标线程对象的引用，且若跨线程调用需通过安全权限检查（否则抛出SecurityException）。

⏳ `yield()`方法的调用范围

线程内调用： yield()是静态方法，只能在当前运行线程内部调用（如Thread.yield()）。它的作用是提示调度器让出当前线程的CPU使用权，使当前线程从运行状态（Running）转为就绪状态（Ready）。
线程外调用： 无法在其他线程中调用yield()控制目标线程。因为yield()仅影响调用它的当前线程，且不接收任何线程对象参数。

💎 关键区别总结

方法	线程内调用	线程外调用	行为特点
`interrupt()`	支持（如`Thread.currentThread().interrupt()`）	支持（需持有目标线程引用）	设置中断标志或抛出异常；可跨线程控制目标线程中断。
`yield()`	支持（`Thread.yield()`）	不支持（无法让其他线程让出CPU）	仅影响当前线程；提示调度器让出CPU，不保证立即切换；不释放锁。

⚠️ 使用注意事项

```
interrupt()
```
的可靠性：
- 若目标线程未检查中断标志或未处理InterruptedException，中断可能无效。
- I/O阻塞（如socket.accept()）无法通过interrupt()中断，需关闭底层资源。
```
yield()
```
的局限性：
- 仅是提示而非强制让出CPU，实际效果依赖操作系统调度器。
- 过度使用可能导致频繁线程切换，降低性能。
设计替代方案：
- 需精确控制线程执行顺序时，优先使用wait/notify、锁或Semaphore。

避免依赖yield()实现同步逻辑（因行为不可预测）。

💡 典型场景示例

interrupt()：主线程等待子线程超时后中断任务：

Thread worker = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        // 执行任务
    }
});
worker.start();
Thread.sleep(5000); // 等待5秒
worker.interrupt(); // 外部中断

yield()：当前线程在耗时循环中主动让出CPU：

public void run() {
    for (int i = 0; i < 1000000; i++) {
        if (i % 1000 == 0) Thread.yield(); // 每1000次迭代让出CPU
    }
}

✅ 总结

interrupt()：支持线程内外调用，是跨线程协作的核心中断机制。
yield()：仅支持线程内调用，用于当前线程主动优化CPU资源分配，不影响其他线程。两者均需结合线程状态和任务逻辑谨慎使用，避免误用导致性能或稳定性问题。

yield()

在Java多线程编程中，Thread.yield()方法用于提示线程调度器当前线程愿意暂时让出CPU资源。以下是调用yield()后线程状态的变化及其后续执行行为的详细分析：

⚙️ 线程状态的变化

从运行态转为就绪态
- 当线程调用yield()时，会从运行状态（Running） 主动退回到就绪状态（Runnable）。
- 关键特性：
  - 非阻塞：线程不会进入阻塞（Blocked）或等待（Waiting）状态，仅释放当前CPU时间片。
  - 不释放锁：即使让出CPU，线程仍持有已获取的锁资源，其他线程无法抢占这些锁。
  - 无休眠时间：与sleep()不同，yield()不指定暂停时长，线程可立即参与下一轮CPU竞争。
操作系统调度器的角色
- yield()仅是提示性请求，操作系统调度器可忽略该请求，继续让当前线程执行。
- 若调度器接受请求，会从就绪队列中选择其他线程执行（优先级相同或更高的线程可能优先）。

🔄 后续能否重新继续执行？

立即重新调度的可能性
- 线程调用
```
yield()
```
  后仍处于就绪队列，可能被立即重新选中执行。例如：
  - 若系统中无其他就绪线程，调度器可能再次分配CPU给该线程。
  - 若线程优先级较高，重获执行权的概率更高（尽管规范要求优先同级线程）。

执行位置的延续性

线程被重新调度后，从yield()之后的代码继续执行，而非从头开始。

示例：

public void run() {
    for (int i = 0; i < 5; i++) {
        System.out.println(i);
        if (i == 2) Thread.yield(); // 让出CPU
    }
}

若线程在

i=2

时让出CPU，恢复后直接从

i=3

继续循环。

⚠️ 重要注意事项

行为的不确定性
- ```
yield()
```
  的效果高度依赖操作系统和JVM实现：
  - 在Windows和Linux等系统中，调度策略差异可能导致结果不一致。
  - 测试时需多次运行观察（如示例代码中线程交替顺序不固定）。

与sleep(0)的区别

特性	`yield()`	`sleep(0)`
状态变化	运行态 → 就绪态	运行态 → 阻塞态（TIMED_WAITING）
锁释放	否	否
调度层级	JVM层面提示	操作系统级调度
异常处理	无	需处理`InterruptedException`

注：sleep(0)会触发操作系统级线程切换，而yield()仅在JVM层面提示。

适用场景与限制
- 适用：调试、性能测试、自旋等待优化（如减少CPU空转）。
- 避免：
  - 依赖yield()控制线程顺序（结果不可靠）；
  - 频繁调用导致线程切换开销激增（降低性能）。

💎 总结

状态变化：yield()使线程从运行态 → 就绪态，不阻塞、不释放锁。
后续执行：线程可能立即被重新调度，且从yield()后代码继续执行。
核心风险：行为不可预测，不应用于关键线程同步（优先使用Lock、Semaphore等）。

通过yield()，开发者可提示系统优化资源分配，但需理解其非强制性本质，避免误用为同步机制。

主线程

主线程在Java中与其他线程地位相同，其调用yield()或interrupt()的可行性及效果需分情况讨论。以下是具体分析：

⚙️ 主线程调用 `yield()`

可行性： 支持调用。yield()是静态方法，主线程可通过Thread.yield()主动让出CPU。
行为效果：
- 状态变化：主线程从运行态（Running） 转为就绪态（Runnable），允许其他同级或更高优先级线程获得CPU时间片。
- 不确定性：调度器可能忽略该提示，主线程可能立即被重新调度（尤其在无其他活跃线程时）。
- 无锁释放：即使让出CPU，主线程仍持有已获取的锁资源。
典型场景：主线程在循环中执行密集型计算时，适时调用yield()避免长时间独占CPU，提升其他后台线程响应性（如GUI事件处理）。

⚡ 主线程调用 `interrupt()`

（1）中断自身（`Thread.currentThread().interrupt()`）

可行性： 支持调用。主线程可中断自己，设置自身的中断标志位为true。
行为效果：
- 中断状态标记：仅设置标志位，不会强制终止主线程。
- 后续响应：主线程需主动检查中断状态（如Thread.interrupted()）并决定是否退出任务。
- 异常触发：若主线程在阻塞方法（如Thread.sleep()）中，会立即抛出InterruptedException并清除中断标志。

典型场景：

在捕获

InterruptedException

后恢复中断状态，确保上层逻辑感知中断请求：

try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // 重置中断标志
    System.out.println("主线程中断已恢复");
}

（2）中断其他线程

可行性： 支持调用。主线程可通过持有目标线程的引用（如childThread.interrupt()）中断子线程。
行为效果：
- 子线程状态：
  - 若子线程在运行中，仅设置中断标志，需子线程主动检查并响应。
  - 若子线程在阻塞中（如sleep()），会抛出InterruptedException并清除中断标志。
- 权限要求：需持有目标线程对象引用，且可能受SecurityManager限制。

典型场景：

主线程超时后中断子线程：

Thread worker = new Thread(() -> {
    while (!Thread.interrupted()) {
        // 执行任务
    }
});
worker.start();
Thread.sleep(5000); // 等待5秒
worker.interrupt(); // 主线程中断子线程

⚠️ 关键注意事项

操作	可行性	风险/限制	替代方案
主线程yield	✔️ 支持	效果不可靠（依赖调度器）；频繁调用增加上下文切换开销	使用`Semaphore`控制并发资源分配
主线程中断自身	✔️ 支持	不自动终止线程，需配合状态检查；阻塞中触发异常需重置标志	设计协作式终止逻辑
主线程中断子线程	✔️ 支持（需引用权限）	子线程不检查中断则无效；I/O阻塞无法中断（需关闭底层资源）	使用`Future.cancel()`管理线程池任务

💎 总结

yield()：主线程可主动让出CPU，但效果不保证，适用于优化资源分配，非同步控制。

interrupt()
```：
- 中断自身：需显式检查状态或处理阻塞异常；
- 中断子线程：需目标线程协作响应，否则无效。
  **合理利用中断机制可实现优雅终止，而`yield()`应谨慎用于性能调优**。

守护进程

守护线程（Daemon Thread）在Java中不会干扰JVM的正常退出，其核心机制基于其生命周期设计和JVM的退出规则。以下是具体原因的分点解析：

⚙️ 生命周期依赖非守护线程

绑定关系：守护线程的存在是为了服务非守护线程（用户线程）。当所有用户线程结束时，JVM会立即终止所有守护线程并退出，无论守护线程是否完成任务。
设计原则：守护线程被定义为“辅助性角色”（如垃圾回收、日志记录），其任务结果不影响程序核心逻辑的完成。因此，当被服务的对象（用户线程）消失时，守护线程失去存在意义，JVM无需等待其结束。

🔄 JVM退出规则

触发条件：JVM退出的唯一条件是所有用户线程终止。守护线程的运行状态不参与此判断。

// 示例：主线程退出后，JVM无视守护线程直接退出
public static void main(String[] args) {
    Thread daemonThread = new Thread(() -> {
        while (true) System.out.println("Daemon running...");
    });
    daemonThread.setDaemon(true);
    daemonThread.start();
    System.out.println("Main thread exits → JVM exits");
}

输出：主线程结束后，守护线程的循环被强制终止，JVM退出。

⚠️ 资源与任务的中断机制

无资源持有要求：守护线程不应持有需要显式释放的资源（如文件锁、数据库连接）。因为JVM退出时不会调用其finally块或清理资源，可能导致泄漏。
任务可中断性：守护线程通常设计为可随时中断的任务（如周期性日志写入）。若任务需原子性完成（如事务提交），则不适合用守护线程。

🧩 与用户线程的本质区别

特性	用户线程	守护线程
阻止JVM退出	是（只要存在即阻止）	否（不参与JVM存活判断）
任务重要性	核心逻辑（如数据处理）	辅助任务（如垃圾回收）
资源管理	需显式释放资源	避免持有关键资源
生命周期控制	需主动结束或等待完成	随用户线程结束自动终止

💡 典型应用场景的合理性

垃圾回收（GC）：GC线程是守护线程的典范。当用户线程全部结束后，内存中不再产生新垃圾，GC线程无需继续运行，JVM退出符合逻辑。
心跳检测/日志记录：这类任务即使中途中断也不影响程序最终状态（如日志丢失部分记录可接受）。

⚠️ 注意：潜在风险与限制

不可靠的终止：守护线程中finally代码块可能不执行，导致清理逻辑失效。
阻塞操作的风险：若守护线程因I/O阻塞（如socket.accept()），而所有用户线程已结束，JVM仍会强制退出，可能破坏操作原子性。
错误使用干扰JVM：
- 在守护线程中调用Thread.join()会阻塞调用者（如主线程），反而阻止JVM退出。
- 若守护线程创建新用户线程，会违反JVM退出条件。

💎 总结

守护线程不干扰JVM的本质在于：

定位机制：作为用户线程的“附属品”，其存活无独立价值；
退出规则：JVM仅依赖用户线程判断退出时机，守护线程被强制终止；
任务设计：适用于可丢弃、非关键的后台任务。 合理使用守护线程能提升后台任务效率，但需严格规避关键操作和资源持有。

Thread 类

⚙️ 线程的创建方式

🔧 Thread类的核心方法

📌 线程属性与状态

⚠️ 高级特性与注意事项

💎 实践建议

总结

Thread 类默认实现

⚙️ 默认构造方法：Thread()

🧩 线程组（ThreadGroup）

📛 线程名称生成机制

⚖️ 守护状态与优先级继承

🔍 线程栈大小（stackSize）

⚠️ 默认实现的实践意义与风险

💎 总结

run()

Runnable

🔧 设计哲学：职责分离与组合优于继承

⚙️ 技术实现：委托机制与默认逻辑

🚀 实际应用：灵活性与生态兼容

🔧 底层实现：基于锁与等待队列

（1）阻塞当前线程

（2）唤醒机制

⚠️ 中断处理

🔄 超时控制

💎 总结：等待的“信号”是什么？

Interrupt() & yield()

⚙️ interrupt()方法的调用范围

⏳ yield()方法的调用范围

💎 关键区别总结

⚠️ 使用注意事项

💡 典型场景示例

✅ 总结

yield()

⚙️ 线程状态的变化

🔄 后续能否重新继续执行？

⚠️ 重要注意事项

💎 总结

主线程

⚙️ 主线程调用 yield()

⚡ 主线程调用 interrupt()

（1）中断自身（Thread.currentThread().interrupt()）

（2）中断其他线程

⚠️ 关键注意事项

💎 总结

守护进程

⚙️ 生命周期依赖非守护线程

🔄 JVM退出规则

⚠️ 资源与任务的中断机制

🧩 与用户线程的本质区别

💡 典型应用场景的合理性

⚠️ 注意：潜在风险与限制

💎 总结

`Thread` 类默认实现

⚙️ 默认构造方法：`Thread()`

⚙️ `interrupt()`方法的调用范围

⏳ `yield()`方法的调用范围

⚙️ 主线程调用 `yield()`

⚡ 主线程调用 `interrupt()`

（1）中断自身（`Thread.currentThread().interrupt()`）