Java线程生命周期全解析：从入门到精通的终极指南！

文章目录

引言

🔥 一文掌握线程六大状态 + 方法详解 + 状态切换原理，带你吃透面试高频考点！

📌 一、Java线程到底经历了几个状态？

Java 中的线程生命周期由 Thread.State 枚举定义，主要有以下 6个状态：

public enum Thread.State {
    NEW,           // 新建
    RUNNABLE,      // 就绪/运行中
    BLOCKED,       // 阻塞（等待锁）
    WAITING,       // 无限等待
    TIMED_WAITING, // 限时等待
    TERMINATED     // 终止
}

🧭 二、线程生命周期状态切换图

                +-------------+
                |     NEW     |
                +-------------+
                      |
                      | start()
                      v
                +-------------+
                |  RUNNABLE   |<-------------------+
                +-------------+                    |
                 |    ^                            |
     获取CPU运行 |    | 线程阻塞或等待资源            |
                 v    |                            |
     +----------+----------+       超时/唤醒        |
     |   BLOCKED / WAITING |---------------------+  |
     |   / TIMED_WAITING   |                      |  |
     +---------------------+                      |  |
                 |                                 |  |
                 v                                 |  |
            +-------------+                        |  |
            | TERMINATED  |<-----------------------+  |
            +-------------+  run()执行完/抛异常       |

📖 三、六大状态逐个拆解（含源码视角）

1️⃣ NEW（新建）

Thread t = new Thread();
System.out.println(t.getState()); // NEW

2️⃣ RUNNABLE（可运行）

Thread t = new Thread(() -> {
    while (true) {}
});
t.start();
System.out.println(t.getState()); // RUNNABLE（可能）

3️⃣ BLOCKED（阻塞）

Object lock = new Object();
Thread t1 = new Thread(() -> {
    synchronized (lock) {
        try { Thread.sleep(5000); } catch (Exception ignored) {}
    }
});
Thread t2 = new Thread(() -> {
    synchronized (lock) {
        System.out.println("t2 acquired lock");
    }
});
t1.start(); t2.start();
Thread.sleep(1000);
System.out.println(t2.getState()); // BLOCKED

4️⃣ WAITING（无限等待）

Thread t = new Thread(() -> {
    synchronized (Thread.class) {
        try {
            Thread.class.wait();
        } catch (InterruptedException e) {}
    }
});
t.start();
Thread.sleep(1000);
System.out.println(t.getState()); // WAITING

5️⃣ TIMED_WAITING（限时等待）

Thread t = new Thread(() -> {
    try { Thread.sleep(5000); } catch (InterruptedException e) {}
});
t.start();
Thread.sleep(1000);
System.out.println(t.getState()); // TIMED_WAITING

6️⃣ TERMINATED（终止）

Thread t = new Thread(() -> System.out.println("done"));
t.start();
t.join();
System.out.println(t.getState()); // TERMINATED

🔧 四、常用线程方法详解

方法	作用	影响状态	说明
`start()`	启动线程	NEW → RUNNABLE	自动调用 `run()`，由 JVM 调度
`run()`	线程逻辑	无	不应手动调用 `run()`
`sleep(ms)`	休眠	RUNNING → TIMED_WAITING	不释放锁
`join()`	等待线程执行结束	当前线程进入 WAITING/TIMED_WAITING	可用于线程协作
`interrupt()`	中断线程	任意状态	设置中断标志位或唤醒阻塞线程
`wait()` / `wait(ms)`	等待锁/通知	WAITING / TIMED_WAITING	需在 `synchronized` 中使用
`notify()` / `notifyAll()`	唤醒等待线程	WAITING → RUNNABLE	单个/全部唤醒

🧵 五、实战案例：线程状态切换模拟器

public class ThreadLifecycleDemo {
    public static void main(String[] args) throws Exception {
        Object lock = new Object();

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread entering WAITING...");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Thread resumed...");
            }
        });

        thread.start();
        Thread.sleep(1000);
        System.out.println("State after start: " + thread.getState()); // WAITING

        synchronized (lock) {
            lock.notify();
        }

        Thread.sleep(1000);
        System.out.println("State after notify: " + thread.getState()); // TERMINATED
    }
}

💡 六、面试真题强化训练

Q1：线程调用 `sleep()` 会释放锁吗？

❌ 不会释放锁！sleep() 只是让线程暂停，仍持有锁。

Q2：`wait()` 和 `sleep()` 区别？

对比项	wait()	sleep()
是否释放锁	✅ 是	❌ 否
使用位置	synchronized 内部	任意
唤醒方式	notify/notifyAll	时间结束或 interrupt
异常	InterruptedException	InterruptedException

Q3：线程池中线程怎么生命周期管理？

实际线程由线程池统一调度：
- 初次任务：NEW → RUNNABLE → TERMINATED
- 重复利用：RUNNABLE ←→ TIMED_WAITING（keepAlive）

✅ 七、总结

状态	含义	常见触发方式
NEW	新建，未 start	new Thread()
RUNNABLE	就绪/运行中	start()
BLOCKED	等待锁	synchronized
WAITING	无限等待	wait() / join()
TIMED_WAITING	限时等待	sleep() / wait(ms)
TERMINATED	执行完成或异常	run() 结束