Java 线程生命周期与状态转换的核心路径_Java

一、前言

在上一篇文章中，我们学习了 java 中创建线程的 5 种方式，掌握了线程的基础创建与启动逻辑。但线程从创建到销毁并非一成不变，而是会在不同状态之间转换。理解线程的生命周期和状态转换，是解决多线程并发问题的关键。

本文将从理论到实践，深入解析 java 线程的 6 种状态，演示状态转换的核心路径，并通过工具分析线程状态，帮助大家彻底掌握这一核心知识点。

二、java 线程的 6 种状态

java 线程的状态被明确枚举在 thread.state 中，共包含 6 种状态，任何时刻一个线程只能处于其中一种状态。

状态名称	核心含义	进入条件	退出条件
new （新建）	线程对象已创建，但未调用start()方法	创建 thread 实例后，未执行 start()	调用 start() 方法
runnable （可运行）	线程正在 cpu 上执行，或处于就绪状态等待 cpu 调度	调用 start() 方法；从其他阻塞 / 等待状态唤醒	线程执行完毕；进入阻塞 / 等待状态
blocked （阻塞）	线程因竞争锁失败而被阻塞	线程尝试进入 synchronized 代码块 / 方法，但锁被其他线程持有	成功获取到锁
waiting （等待）	线程无时间限制等待，需其他线程主动唤醒	调用 object.wait()（无参）、thread.join()（无参）、locksupport.park()	其他线程调用 object.notify()/notifyall()、被 join 的线程执行完毕、调用 locksupport.unpark()
timed_waiting （超时等待）	线程有时间限制等待，超时后自动唤醒	调用 thread.sleep(long)、object.wait(long)、thread.join(long)、locksupport.parknanos()/parkuntil()	超时自动唤醒；其他线程提前唤醒
terminated （终止）	线程执行完毕或异常退出	run() 方法执行完成；线程执行过程中抛出未捕获异常	无（线程生命周期结束）

三、线程状态转换流程图

四、线程状态转换

线程状态转换有固定的核心路径，我们通过代码案例逐一演示关键转换场景，直观观察状态变化。

前置说明

所有案例中，使用 thread.getstate() 方法获取线程当前状态。
为了精准观察状态，使用 thread.sleep() 控制线程执行节奏，避免因 cpu 调度过快导致状态无法捕捉。

场景 1：new → runnable → terminated（基础路径）

核心逻辑：线程创建后处于 new 状态，调用 start() 进入 runnable ，执行完 run() 后进入 terminated 。

public class threadstatedemo1 {
    public static void main(string[] args) throws interruptedexception {
        // 1. 创建线程，此时状态为 new
        thread thread = new thread(() -> {
            system.out.println("线程执行中，当前状态：" + thread.currentthread().getstate());
            // 模拟任务执行
            try {
                thread.sleep(100);
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
        }, "基础状态线程");
        system.out.println("调用start()前，线程状态：" + thread.getstate()); // new
        // 2. 启动线程，进入 runnable 状态
        thread.start();
        thread.sleep(50); // 等待线程进入执行状态
        system.out.println("线程执行中，主线程观察到的状态：" + thread.getstate()); // runnable
        // 3. 等待线程执行完毕
        thread.join();
        system.out.println("线程执行完毕，当前状态：" + thread.getstate()); // terminated
    }
}

运行结果

调用start()前，线程状态：new
线程执行中，当前状态：runnable
线程执行中，主线程观察到的状态：runnable
线程执行完毕，当前状态：terminated

场景 2：runnable → blocked → runnable（锁竞争导致阻塞）

核心逻辑：线程尝试获取 synchronized 锁失败时，进入 blocked 状态；成功获取锁后，回到 runnable 。

public class threadstatedemo2 {
    // 定义一个锁对象
    private static final object lock = new object();
    public static void main(string[] args) throws interruptedexception {
        // 线程1：先获取锁，持有锁1秒
        thread thread1 = new thread(() -> {
            synchronized (lock) {
                try {
                    system.out.println(thread.currentthread().getname() + " 获取到锁，状态：runnable");
                    thread.sleep(1000); // 持有锁，让线程2阻塞
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        }, "线程1");
        // 线程2：后获取锁，会进入 blocked 状态
        thread thread2 = new thread(() -> {
            synchronized (lock) {
                system.out.println(thread.currentthread().getname() + " 成功获取锁，状态回到 runnable");
            }
        }, "线程2");
        // 启动线程1和线程2
        thread1.start();
        thread.sleep(100); // 确保线程1先获取锁
        thread2.start();
        // 观察线程2的状态
        thread.sleep(200);
        system.out.println(thread2.getname() + " 等待锁，状态：" + thread2.getstate()); // blocked
        // 等待线程1执行完毕，线程2获取锁
        thread1.join();
        thread.sleep(200);
        system.out.println(thread2.getname() + " 执行中，状态：" + thread2.getstate()); // runnable
    }
}

运行结果

线程1 获取到锁，状态：runnable
线程2 等待锁，状态：blocked
线程2 成功获取锁，状态回到 runnable
线程2 执行中，状态：runnable

场景 3：runnable → waiting → runnable（无参 wait () 唤醒）

核心逻辑：线程调用 object.wait() （无参）后，释放锁并进入 waiting 状态；需其他线程调用 notify() / notifyall() 唤醒，重新竞争锁后回到 runnable 。

public class threadstatedemo3 {
    private static final object lock = new object();
    private static thread waitthread; // 等待线程
    public static void main(string[] args) throws interruptedexception {
        // 等待线程：调用wait()进入waiting状态
        waitthread = new thread(() -> {
            synchronized (lock) {
                try {
                    system.out.println(thread.currentthread().getname() + " 调用wait()，进入waiting状态");
                    lock.wait(); // 无参wait，释放锁
                    system.out.println(thread.currentthread().getname() + " 被唤醒，状态回到runnable");
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        }, "等待线程");
        // 唤醒线程：调用notify()唤醒等待线程
        thread notifythread = new thread(() -> {
            synchronized (lock) {
                system.out.println(thread.currentthread().getname() + " 获取锁，准备唤醒等待线程");
                lock.notify(); // 唤醒等待线程
                try {
                    thread.sleep(500); // 持有锁，让等待线程先处于waiting→blocked
                } catch (interruptedexception e) {
                    e.printstacktrace();
                }
            }
        }, "唤醒线程");
        waitthread.start();
        thread.sleep(200);
        system.out.println(waitthread.getname() + " 当前状态：" + waitthread.getstate()); // waiting
        notifythread.start();
        notifythread.join();
        thread.sleep(200);
        system.out.println(waitthread.getname() + " 最终状态：" + waitthread.getstate()); // runnable/terminated
    }
}

运行结果

等待线程调用wait()，进入waiting状态
等待线程当前状态：waiting
唤醒线程获取锁，准备唤醒等待线程
等待线程被唤醒，状态回到runnable
等待线程最终状态：terminated

场景 4：runnable → timed_waiting → runnable（sleep () 超时唤醒）

核心逻辑：线程调用 thread.sleep(long) 后，进入 timed_waiting 状态；超时后自动唤醒，回到 runnable 状态（ sleep () 不会释放锁 ）。

public class threadstatedemo4 {
    public static void main(string[] args) throws interruptedexception {
        thread sleepthread = new thread(() -> {
            try {
                system.out.println(thread.currentthread().getname() + " 调用sleep(1000)，进入timed_waiting状态");
                thread.sleep(1000); // 超时等待1秒
            } catch (interruptedexception e) {
                e.printstacktrace();
            }
            system.out.println(thread.currentthread().getname() + " 超时唤醒，状态回到runnable");
        }, "睡眠线程");
        sleepthread.start();
        thread.sleep(200);
        system.out.println(sleepthread.getname() + " 当前状态：" + sleepthread.getstate()); // timed_waiting
        sleepthread.join();
        system.out.println(sleepthread.getname() + " 执行完毕，状态：" + sleepthread.getstate()); // terminated
    }
}

运行结果

睡眠线程调用sleep(1000)，进入timed_waiting状态
睡眠线程当前状态：timed_waiting
睡眠线程超时唤醒，状态回到runnable
睡眠线程执行完毕，状态：terminated

五、使用 jstack 命令分析线程状态

在实际开发中，我们无法通过代码实时观察线上线程的状态，此时可以使用 jdk 自带的 jstack 命令，查看线程的状态和调用栈，定位线程阻塞、死锁等问题。

1、操作步骤

1. 获取进程 id：使用 jps 命令，查看 java 进程的 pid。

jps
# 输出示例：1234 threadstatedemo2 （1234为pid）

2. 导出线程快照：使用 jstack pid > thread_dump.txt 命令，将线程快照导出到文件。

jstack 1234 > thread_dump.txt

3. 分析线程状态：打开 thread_dump.txt 文件，搜索线程名称，查看线程状态。

2、实战案例（分析 blocked 状态线程）

在 threadstatedemo2 运行时，导出线程快照，会看到类似如下内容：

"线程2" #13 prio=5 os_prio=31 tid=0x00007f8b1282e000 nid=0x5003 waiting for monitor entry [0x0000700001a6f000]
   java.lang.thread.state: blocked (on object monitor)
        at threadstatedemo2.lambda$main$1(threadstatedemo2.java:18)
        - waiting to lock <0x000000076ab81810> (a java.lang.object)
        - locked <0x000000076ab81810> (a java.lang.object)

java.lang.thread.state: blocked (on object monitor)：明确线程处于 blocked 状态。
waiting to lock <0x000000076ab81810>：表示线程正在等待获取该地址的锁。

六、常见误区辨析

runnable 状态 ≠ 正在执行：runnable 包含 “就绪” 和 “运行中” 两种情况，只有获取到 cpu 时间片的线程才会真正执行。
sleep () 和 wait () 的区别： sleep() 属于 thread 类，不会释放锁，超时自动唤醒； wait() 属于 object 类，会释放锁，需要其他线程唤醒。
blocked 和 waiting 的区别： blocked 是因竞争锁阻塞， waiting 是因调用 wait() / join() 等方法主动等待。