Java有哪些线程状态

在Java中，线程是程序执行的最小单元，线程的状态反映了线程在其生命周期中的不同阶段。了解线程的状态对于编写高效、稳定的多线程程序至关重要。本文将详细介绍Java中的线程状态，包括每种状态的定义、转换条件以及相关的代码示例。

1. 线程状态概述

Java中的线程状态由java.lang.Thread.State枚举类定义，共有六种状态：

1. NEW（新建）
2. RUNNABLE（可运行）
3. BLOCKED（阻塞）
4. WTING（等待）
5. TIMED_WTING（计时等待）
6. TERMINATED（终止）

这些状态描述了线程在其生命周期中的不同阶段。下面我们将逐一介绍每种状态。

2. NEW（新建）

2.1 定义

当一个线程对象被创建但尚未启动时，它处于NEW状态。此时，线程还没有开始执行，也没有分配任何系统资源。

2.2 代码示例

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

2.3 状态转换

• NEW -> RUNNABLE：调用start()方法后，线程从NEW状态转换为RUNNABLE状态。

3. RUNNABLE（可运行）

3.1 定义

当线程调用start()方法后，线程进入RUNNABLE状态。此时，线程已经准备好运行，但可能还没有真正开始执行，具体取决于操作系统的调度。

3.2 代码示例

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

3.3 状态转换

• RUNNABLE -> BLOCKED：线程尝试获取一个对象的锁，但该锁已被其他线程持有，线程将进入BLOCKED状态。
• RUNNABLE -> WTING：线程调用了Object.wait()、Thread.join()或LockSupport.park()方法，线程将进入WTING状态。
• RUNNABLE -> TIMED_WTING：线程调用了Thread.sleep(long millis)、Object.wait(long timeout)、Thread.join(long millis)或LockSupport.parkNanos(long nanos)等方法，线程将进入TIMED_WTING状态。
• RUNNABLE -> TERMINATED：线程执行完毕，进入TERMINATED状态。

4. BLOCKED（阻塞）

4.1 定义

当线程尝试获取一个对象的锁，但该锁已被其他线程持有时，线程将进入BLOCKED状态。此时，线程无法继续执行，直到锁被释放。

4.2 代码示例

Object lock = new Object();

Thread thread1 = new Thread(() -> {
    synchronized (lock) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

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

thread1.start();
thread2.start();

Thread.sleep(500); // 确保thread1先获取锁
System.out.println("Thread2 state: " + thread2.getState()); // 输出: Thread2 state: BLOCKED

4.3 状态转换

• BLOCKED -> RUNNABLE：当锁被释放后，线程将重新进入RUNNABLE状态，等待CPU调度。

5. WTING（等待）

5.1 定义

当线程调用了Object.wait()、Thread.join()或LockSupport.park()方法时，线程将进入WTING状态。此时，线程将无限期地等待，直到其他线程唤醒它。

5.2 代码示例

Object lock = new Object();

Thread thread = new Thread(() -> {
    synchronized (lock) {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

thread.start();
Thread.sleep(500); // 确保线程进入WTING状态
System.out.println("Thread state: " + thread.getState()); // 输出: Thread state: WTING

5.3 状态转换

• WTING -> RUNNABLE：当其他线程调用Object.notify()或Object.notifyAll()方法时，线程将被唤醒，重新进入RUNNABLE状态。

6. TIMED_WTING（计时等待）

6.1 定义

当线程调用了Thread.sleep(long millis)、Object.wait(long timeout)、Thread.join(long millis)或LockSupport.parkNanos(long nanos)等方法时，线程将进入TIMED_WTING状态。此时，线程将等待指定的时间，或者被其他线程唤醒。

6.2 代码示例

Thread thread = new Thread(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});

thread.start();
Thread.sleep(500); // 确保线程进入TIMED_WTING状态
System.out.println("Thread state: " + thread.getState()); // 输出: Thread state: TIMED_WTING

6.3 状态转换

• TIMED_WTING -> RUNNABLE：当等待时间到期或被其他线程唤醒时，线程将重新进入RUNNABLE状态。

7. TERMINATED（终止）

7.1 定义

当线程执行完毕或因为异常而终止时，线程将进入TERMINATED状态。此时，线程的生命周期结束，无法再次启动。

7.2 代码示例

Thread thread = new Thread(() -> {
    System.out.println("Thread is running");
});

thread.start();
thread.join(); // 等待线程执行完毕
System.out.println("Thread state: " + thread.getState()); // 输出: Thread state: TERMINATED

7.3 状态转换

• TERMINATED：线程一旦进入TERMINATED状态，就无法再转换到其他状态。

8. 线程状态转换图

为了更直观地理解线程状态的转换，下面是一个线程状态转换图：

NEW -> RUNNABLE -> BLOCKED
         |          |
         v          v
      WTING <-> TIMED_WTING
         |
         v
      TERMINATED

9. 总结

Java中的线程状态是理解多线程编程的基础。通过了解每种状态的定义、转换条件以及相关的代码示例，我们可以更好地掌握线程的生命周期，从而编写出高效、稳定的多线程程序。在实际开发中，合理管理线程状态，避免死锁、资源竞争等问题，是确保程序正确运行的关键。

10. 参考资料

• Java Thread States
• Java Concurrency in Practice
• Java多线程编程实战指南

---

通过本文的详细介绍，相信读者对Java中的线程状态有了更深入的理解。在实际开发中，合理管理线程状态，避免死锁、资源竞争等问题，是确保程序正确运行的关键。希望本文能帮助读者在多线程编程中更加得心应手。