Java 线程状态全解析：从创建到终止的生命周期

在 Java 多线程编程中，理解线程的状态是掌握并发编程的基础。线程在其生命周期中会经历多种状态，每种状态都对应着特定的运行阶段。本文将详细介绍 Java 线程的 6 种状态，帮助你更清晰地把握线程的运行机制。

一、Java 线程的 6 种状态

1. 新建状态（New）
2. 运行状态（Runnable）
3. 阻塞状态（Blocked）
4. 等待状态（Waiting）
5. 超时等待状态（Timed Waiting）
6. 终止状态（Terminated）

二、代码演示各状态及转换

1. 新建状态（NEW）

含义：线程对象已创建，但未调用start()方法，未与操作系统线程关联。(安排了工作还未开始，new了Thread对象，但是还没start)

public class ThreadStateNewDemo {
    public static void main(String[] args) {
        Thread t=new Thread(()->{});// 创建线程对象
        System.out.println(t.getState());// 输出：NEW
        //t.start();
    }
}

2. 运行状态（RUNNABLE）

含义：线程已启动（调用start()），处于 “就绪” 或 “正在运行” 状态（由 CPU 调度决，可工作的，又可以分为正在工作中和即将开始工作。1.线程正在cpu上运行。2.线程随时可以去cpu上执行）

2.1 “就绪”状态

public class ThreadStateRunnableDemo {
    public static void main(String[] args) throws InterruptedException {
   
        Thread t=new Thread(()->{});
        t.start();// 启动线程，进入RUNNABLE
        System.out.println(t.getState());
        t.join();
    }
}

2.2 “正在运行” 状态

ublic class RunnableStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            // 线程执行任务（会被CPU调度，处于RUNNABLE）
            for (int i = 0; i < 1000000; i++) {}
        });
        
        t.start(); // 启动线程，进入RUNNABLE
        System.out.println(t.getState()); // 大概率输出：RUNNABLE（取决于调度）
        t.join(); // 等待线程执行完毕
    }

3. 阻塞状态（BLOCKED）

含义：线程因竞争synchronized锁失败而等待锁的状态。（这几个都表示排队等着其他事情。也是一种阻塞,比较特殊, 由于锁导致的阻塞.）

public class BlockedStateDemo {
    // 共享锁对象
    private static final Object locker = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (locker) { // t1先获取锁
                try { Thread.sleep(1000); } // 持有锁休眠，让t2有时间竞争
                catch (InterruptedException e) {}
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (locker) { // t2尝试获取锁（此时t1持有锁，t2进入BLOCKED）
                System.out.println("t2获得锁");
            }
        });

        t1.start();
        Thread.sleep(100); // 确保t1先启动并获取锁
        t2.start();
        Thread.sleep(100); // 等待t2进入阻塞状态
        
        System.out.println(t2.getState()); // 输出：BLOCKED
    }
}

4. 等待状态（WAITING）

含义：线程无限期等待被其他线程唤醒（死等，没有超时时间的阻塞等待）。

public class WaitingStateDemo {
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait(); // 调用wait()进入WAITING，释放锁
                } catch (InterruptedException e) {}
            }
        });

        t.start();
        Thread.sleep(100); // 等待t进入WAITING
        

5. 超时等待状态（TIMED_WAITING）

含义：线程等待指定时间后自动唤醒，或被提前唤醒。

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000); // 休眠1秒，进入TIMED_WAITING
            } catch (InterruptedException e) {}
        });

        t.start();
        Thread.sleep(100); // 等待t进入超时等待
        
        System.out.println(t.getState()); // 输出：TIMED_WAITING
    }

另外join()也会进入TIMED_WAITING状态：

public class TimedWaitingStateDemo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread mianThrad=Thread.currentThread(); // 获取main线程的Thread对象
        Thread t=new Thread(()->{
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        t.start();
        t.join(50000);
        System.out.println(mianThrad.getState());  //IMED_WAITING
    }
}

6. 终止状态（TERMINATED）

含义：线程执行完毕（正常结束或异常终止，内核中的线程已经结束了.但是线程(Thread)对象还在。）

public class TerminatedStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            // 线程任务：执行一段简单逻辑
            System.out.println("线程执行中");
        });
        t.start();
        t.join(); // 等待线程执行完毕
        System.out.println(t.getState()); // 输出：TERMINATED
    }
}

三、总结

线程状态反映了线程在生命周期中的不同阶段，通过代码实践可以更清晰地理解：

• NEW和TERMINATED是线程的起点和终点
• RUNNABLE是线程 “活跃” 的核心状态
• BLOCKED、WAITING、TIMED_WAITING是线程 “暂停” 的不同场景（锁竞争、无限等待、有限等待）
  

握这些状态有助于调试并发问题（如线程卡死可能是WAITING状态未被唤醒），是编写高效并发程序的基础。