Java 线程的生命周期是线程从创建到销毁的整个过程，线程在生命周期内会在不同状态间切换。

Java 线程在 java.lang.Thread.State 枚举中定义了6种核心状态，这是线程生命周期的标准定义，也是面试和开发的核心知识点。

一、线程的6种状态（核心）

线程任意时刻只能处于其中一种状态，先记住这6个状态：

1. 新建（NEW）：线程被创建，但还没调用 start() 方法
2. 就绪（RUNNABLE）：线程调用了 start()，等待CPU调度执行
3. 阻塞（BLOCKED）：线程等待锁，无法进入同步代码块/方法
4. 等待（WAITING）：线程无限期等待其他线程唤醒
5. 计时等待（TIMED_WAITING）：线程等待指定时间，时间到自动唤醒
6. 终止（TERMINATED）：线程执行完毕、异常退出，生命周期结束

---

二、状态详细说明 + 切换流程

1. 新建状态（NEW）

• 用 new Thread() 创建线程对象后，线程就是新建状态
• 特点：还未启动，没有和操作系统线程关联

Thread t = new Thread(() -> {});
System.out.println(t.getState()); // 输出：NEW

2. 就绪状态（RUNNABLE）

• 调用 thread.start() 后，线程进入 RUNNABLE
• 这个状态包含两个子状态：
  1. 就绪：等待CPU分配时间片
  2. 运行中：获得CPU，正在执行代码
• Java 把这两个情况统一称为 RUNNABLE

3. 阻塞状态（BLOCKED）

• 场景：线程等待synchronized 锁时进入该状态
• 只有拿到锁，才能从 BLOCKED 回到 RUNNABLE

// 线程A持有锁，线程B尝试获取锁，B会进入 BLOCKED 状态
synchronized (obj) { ... }

4. 等待状态（WAITING）

• 线程主动等待，需要其他线程唤醒才能继续
• 进入 WAITING 的3种方法（无超时参数）：
  • Object.wait()
  • Thread.join()
  • LockSupport.park()
• 唤醒方法：Object.notify() / notifyAll()、LockSupport.unpark()

5. 计时等待状态（TIMED_WAITING）

• 和 WAITING 类似，但有时间限制，时间到自动唤醒
• 进入方法（带超时参数）：
  • Thread.sleep(long)
  • Object.wait(long)
  • Thread.join(long)
  • LockSupport.parkNanos() / parkUntil()

6. 终止状态（TERMINATED）

• 线程生命周期结束，有两种情况：
  1. 正常执行完 run() 方法
  2. 线程抛出未捕获异常，异常退出
• 终止后无法再次启动，调用 start() 会抛异常

---

三、线程状态切换流程图（极简版）

NEW 
  ↓ (调用 start())
RUNNABLE ←→ BLOCKED（等待synchronized锁）
   ↑ ↓
WAITING / TIMED_WAITING（等待/计时等待）
  ↓ (执行完毕/异常)
TERMINATED

---

四、核心状态切换场景（开发高频）

1. sleep 场景：RUNNABLE → TIMED_WAITING → 时间到 → RUNNABLE
2. wait 场景：RUNNABLE → WAITING → 被notify → RUNNABLE
3. 抢锁场景：RUNNABLE → BLOCKED → 拿到锁 → RUNNABLE
4. join 场景：主线程等待子线程 → WAITING → 子线程结束 → 主线程 RUNNABLE

---

五、代码示例：查看线程状态

public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000); // 进入 TIMED_WAITING
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println(t.getState()); // NEW：新建状态
        t.start();
        System.out.println(t.getState()); // RUNNABLE：启动后
        Thread.sleep(500);
        System.out.println(t.getState()); // TIMED_WAITING：sleep中
        t.join();
        System.out.println(t.getState()); // TERMINATED：执行完毕
    }
}

总结

1. Java 线程生命周期有 6种状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED
2. RUNNABLE 是核心状态，包含等待CPU和正在运行
3. BLOCKED 只针对 synchronized 锁等待
4. WAITING 无限等待，TIMED_WAITING 限时等待
5. 线程终止后不可重启