🚀 Java 线程的几种状态详解

在 Java 中，线程状态（Thread State）是由 Thread.State 枚举定义的，总共有六种：

状态	含义	典型场景示例
NEW	新建状态，线程对象刚创建，还未调用 start() 方法。	Thread thread = new Thread();
RUNNABLE	就绪状态，调用了 start() 后，等待 CPU 调度。	thread.start();
BLOCKED	阻塞状态，等待锁资源（例如 synchronized 锁定的对象）。	线程 A 获得锁，线程 B 阻塞等待。
WAITING	无限期等待，等待其他线程唤醒（需要显示调用 notify()、join() 等方法）。	Object.wait()、thread.join()
TIMED_WAITING	计时等待，到时间自动返回（比如 sleep、带超时的 wait）。	Thread.sleep(1000)
TERMINATED	终止状态，线程执行完毕或异常退出。	线程执行完 run() 方法

也就是说，线程的生命周期可以分为五个主要阶段：新建、就绪、运行、阻塞和终止。线程在运行过程中会根据状态的变化在这些阶段之间切换。

class ThreadStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(2000); // TIMED_WAITING
                synchronized (ThreadStateExample.class) {
                    ThreadStateExample.class.wait(); // WAITING
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        System.out.println("State after creation: " + thread.getState()); // NEW

        thread.start();
        System.out.println("State after start: " + thread.getState()); // RUNNABLE

        Thread.sleep(500);
        System.out.println("State while sleeping: " + thread.getState()); // TIMED_WAITING

        synchronized (ThreadStateExample.class) {
            ThreadStateExample.class.notify(); // 唤醒线程
        }

        thread.join();
        System.out.println("State after termination: " + thread.getState()); // TERMINATED
    }
}

---

🔥 用一张 Mermaid 状态图帮你直观理解

---

如何强制终止线程？

第一步，调用线程的 interrupt() 方法，请求终止线程。

第二步，在线程的 run() 方法中检查中断状态，如果线程被中断，就退出线程。

class MyTask implements Runnable {
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                System.out.println("Running...");
                Thread.sleep(1000); // 模拟工作
            } catch (InterruptedException e) {
                // 捕获中断异常后，重置中断状态
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted, exiting...");
                break;
            }
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new MyTask());
        thread.start();
        Thread.sleep(3000); // 主线程等待3秒
        thread.interrupt(); // 请求终止线程
    }
}

中断结果：

---

🧠 小知识点：

• NEW → RUNNABLE：线程调用了 start() 方法，但真正运行由 CPU 调度。
• RUNNABLE → BLOCKED：常见于 synchronized 竞争失败。
• WAITING vs TIMED_WAITING：
  • WAITING 是无限期等待（比如 wait()、join() 不带超时）。
  • TIMED_WAITING 是有时间限制的等待（比如 sleep(1000)，或者 join(5000)）。
• 线程死亡（TERMINATED） 后无法再次 start()，否则抛出 IllegalThreadStateException。