Java线程在其生命周期中会经历多个状态，每个状态在特定的条件下转换。理解这些状态以及它们之间的转换对于编写高效并发程序至关重要。本篇博客将通过详细的源码和示例代码，帮助你深入理解这些状态及其转换。

线程的六种状态

Java线程在运行的生命周期中的指定时刻只可能处于下面六种不同状态的其中一个状态：

1. NEW: 初始状态，线程被创建出来但没有被调用 start() 。
2. RUNNABLE: 运行状态，线程被调用了 start()等待运行的状态。
3. BLOCKED：阻塞状态，等待锁释放。
4. WAITING：等待状态，表示该线程需要等待其他线程做出一些特定动作（通知或中断）。
5. TIME_WAITING：超时等待状态，可以在指定的时间后自行返回而不是像 WAITING 那样一直等待。
6. TERMINATED：终止状态，表示该线程已经运行完毕。

线程状态转换图

为了更好地理解这些状态及其转换，我们可以参考下图：

txt

NEW -> RUNNABLE -> RUNNING -> BLOCKED -> RUNNABLE -> WAITING -> RUNNABLE -> TIME_WAITING -> RUNNABLE -> TERMINATED

线程状态分析

1. NEW（初始状态）

这是线程创建后的初始状态。线程对象已经创建但还未启动，处于该状态。

示例代码：

java

Thread thread = new Thread(() -> {
    System.out.println("Thread is running...");
});
System.out.println("Thread state: " + thread.getState());  // 输出: NEW

2. RUNNABLE（可运行状态）

当调用 start() 方法后，线程进入 RUNNABLE 状态，这意味着线程已经就绪，等待 CPU 调度。

示例代码：

java

Thread thread = new Thread(() -> {
    System.out.println("Thread is running...");
});
thread.start();
System.out.println("Thread state: " + thread.getState());  // 输出: RUNNABLE

3. RUNNING（运行中状态）

实际上，Java不区分RUNNABLE和RUNNING状态。在操作系统层面，线程有 READY 和 RUNNING 状态；而在 JVM 层面，只能看到 RUNNABLE 状态。

4. BLOCKED（阻塞状态）

当一个线程试图获取一个对象的锁而该锁被其他线程持有时，线程进入 BLOCKED 状态。一旦锁被释放，线程又会进入 RUNNABLE 状态。

示例代码：

java

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2 acquired the lock");
            }
        });

        t1.start();
        Thread.sleep(50); // 确保t1先获取锁
        t2.start();

        Thread.sleep(50);
        System.out.println("Thread state: " + t2.getState());  // 输出: BLOCKED
    }
}

5. WAITING（等待状态）

线程进入 WAITING 状态是因为它在等待另一个线程执行特定的动作（如通知或中断）。

示例代码：

java

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

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        Thread.sleep(50); // 确保t1先进入等待状态
        System.out.println("Thread state: " + t1.getState());  // 输出: WAITING
    }
}

6. TIME_WAITING（超时等待状态）

线程进入 TIME_WAITING 状态是因为它在等待指定的时间段。

示例代码：

java

public class TimeWaitingExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t1.start();
        Thread.sleep(50); // 确保t1进入睡眠状态
        System.out.println("Thread state: " + t1.getState());  // 输出: TIME_WAITING
    }
}

7. TERMINATED（终止状态）

当线程执行完run()方法后，线程进入 TERMINATED 状态。

示例代码：

java

public class TerminatedExample {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("Thread is running...");
        });

        t1.start();
        t1.join(); // 确保线程t1执行完毕
        System.out.println("Thread state: " + t1.getState());  // 输出: TERMINATED
    }
}