Java基础教程（135）多线程之线程的状态：线程的生死时速，Java多线程状态全景透析-优快云博客

本文将用生动代码示例带你穿透Java线程的六大状态，彻底掌握状态转换的本质逻辑。

1. 线程状态全景图

Java线程在生命周期中会经历不同的状态，这些状态在Thread.State枚举中明确定义：

public enum State {
    NEW,
    RUNNABLE,
    BLOCKED,
    WAITING,
    TIMED_WAITING,
    TERMINATED;
}

2. 六大状态深度解析

2.1 新建状态(NEW)

当线程对象被创建但尚未启动时：

Thread thread = new Thread(() -> {
    // 线程任务
});
System.out.println(thread.getState()); // 输出: NEW

2.2 可运行状态(RUNNABLE)

一旦调用start()方法，线程进入RUNNABLE状态，注意此状态包含就绪和运行中两种子状态：

thread.start();
System.out.println(thread.getState()); // 输出: RUNNABLE

2.3 阻塞状态(BLOCKED)

线程等待监视器锁时的状态：

public class BlockedStateExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try { Thread.sleep(1000); } 
                catch (InterruptedException e) {}
            }
        });
        
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                // 获取锁
            }
        });
        
        t1.start();
        Thread.sleep(100); // 确保t1先获取锁
        t2.start();
        Thread.sleep(100); // 确保t2已启动
        
        System.out.println(t2.getState()); // 输出: BLOCKED
    }
}

2.4 等待状态(WAITING)

线程无限期等待其他线程执行特定操作：

public class WaitingStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.currentThread().join(); // 自己等待自己，将永远等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        thread.start();
        Thread.sleep(500);
        System.out.println(thread.getState()); // 输出: WAITING
    }
}

2.5 定时等待状态(TIMED_WAITING)

线程等待指定的时间：

public class TimedWaitingStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        thread.start();
        Thread.sleep(500);
        System.out.println(thread.getState()); // 输出: TIMED_WAITING
    }
}

2.6 终止状态(TERMINATED)

线程执行完毕后的状态：

public class TerminatedStateExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            // 简单任务
        });
        
        thread.start();
        Thread.sleep(1000); // 等待线程执行结束
        
        System.out.println(thread.getState()); // 输出: TERMINATED
    }
}

3. 状态转换实战演示

以下示例展示完整的状态流转过程：

public class ThreadLifecycleDemo {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        
        Thread thread = new Thread(() -> {
            // 状态转换：NEW -> RUNNABLE
            synchronized (lock) {
                try {
                    Thread.sleep(1000);        // TIMED_WAITING
                    lock.wait();               // WAITING
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        System.out.println("创建后: " + thread.getState()); // NEW
        
        thread.start();
        System.out.println("启动后: " + thread.getState()); // RUNNABLE
        
        Thread.sleep(100);
        synchronized (lock) {
            System.out.println("获取锁后: " + thread.getState()); // BLOCKED
            lock.notify();
        }
        
        Thread.sleep(100);
        System.out.println("等待后: " + thread.getState()); // TIMED_WAITING
        
        Thread.sleep(2000);
        System.out.println("最终状态: " + thread.getState()); // TERMINATED
    }
}