【Java基础】 线程状态转化

Java 中的线程状态转换是指线程在其生命周期中可以经历的不同状态以及这些状态之间的转换。了解线程的状态转换对于有效地管理和调试多线程应用程序非常重要。Java 提供了 Thread.State 枚举来描述线程的状态。

状态

1. NEW（新建）：

   • 线程被创建，但尚未启动。
   • 线程对象已被创建，但 start() 方法尚未被调用。

2. RUNNABLE（就绪/运行）：

   • 线程已经启动，并且正在等待 CPU 调度或正在执行。
   • 在操作系统层面，Java 线程可能被映射到不同的实际运行状态，但在 Java 虚拟机（JVM）中，这些状态被统一表示为 RUNNABLE。

3. BLOCKED（阻塞）：

   • 线程被阻塞，等待进入一个同步块/方法。
   • 当线程试图获取一个锁而该锁被另一个线程持有时，线程进入 BLOCKED 状态。

4. WAITING（等待）：

   • 线程在等待另一个线程执行特定操作（如通知或中断）。
   • 线程通过调用 Object.wait()、Thread.join() 或 LockSupport.park() 等方法进入 WAITING 状态。

5. TIMED_WAITING（计时等待）：

   • 线程在等待另一个线程的特定操作的同时，也在等待特定的时间。
   • 线程通过调用 Thread.sleep()、Object.wait(long timeout)、Thread.join(long millis) 或 LockSupport.parkNanos() 等方法进入 TIMED_WAITING 状态。

6. TERMINATED（终止）：

   • 线程已完成执行。
   • 线程正常完成或因未捕获的异常而终止，进入 TERMINATED 状态。

 

线程状态转化图

 

状态转换的详细说明 

• 从 NEW 到 RUNNABLE：

  调用 Thread.start() 方法，线程从 NEW 状态转换到 RUNNABLE 状态。

• 从 RUNNABLE 到 BLOCKED：

  当线程尝试获取一个锁（通过 synchronized 关键字或显式锁）但锁被其他线程持有时，线程从 RUNNABLE 转换到 BLOCKED。

• 从 BLOCKED 到 RUNNABLE：

  当线程成功获取到锁时，线程从 BLOCKED 转换到 RUNNABLE。

• 从 RUNNABLE 到 WAITING：

  线程调用 Object.wait()、Thread.join() 或 LockSupport.park() 方法进入 WAITING 状态，等待其他线程的通知或中断。

• 从 WAITING 到 RUNNABLE：

  线程被其他线程通过 Object.notify()、Object.notifyAll()、Thread.interrupt() 或 LockSupport.unpark() 方法唤醒，重新进入 RUNNABLE 状态。

• 从 RUNNABLE 到 TIMED_WAITING：

  线程调用 Thread.sleep(long millis)、Object.wait(long timeout)、Thread.join(long millis) 或 LockSupport.parkNanos(long nanos) 等方法进入 TIMED_WAITING 状态，等待特定的时间。

• 从 TIMED_WAITING 到 RUNNABLE：

  等待时间结束或线程被唤醒后，线程从 TIMED_WAITING 转换到 RUNNABLE。

• 从 RUNNABLE 到 TERMINATED：

  线程执行完 run() 方法或抛出未捕获的异常，线程从 RUNNABLE 转换到 TERMINATED。

 

代码示例 

public class ThreadStateDemo {
    public static void main(String[] args) {
        // 创建一个新线程
        Thread thread = new Thread(() -> {
            try {
                // 输出当前线程的状态（RUNNABLE）
                System.out.println("Thread State: " + Thread.currentThread().getState());
                // 让线程休眠1秒（TIMED_WAITING）
                Thread.sleep(1000);
                // 同步代码块，等待1秒（TIMED_WAITING）
                synchronized (ThreadStateDemo.class) {
                    ThreadStateDemo.class.wait(1000);
                }
                // 输出当前线程的状态（RUNNABLE）
                System.out.println("Thread State: " + Thread.currentThread().getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        // 输出主线程的状态（NEW）
        System.out.println("Thread State: " + thread.getState());
        // 启动新线程
        thread.start();
        // 输出新线程的状态（RUNNABLE，取决于CPU调度）
        System.out.println("Thread State: " + thread.getState());

        try {
            // 主线程休眠500毫秒，确保新线程进入TIMED_WAITING状态
            Thread.sleep(500);
            // 输出新线程的状态（TIMED_WAITING）
            System.out.println("Thread State: " + thread.getState());
            // 等待新线程结束
            thread.join();
            // 输出新线程的状态（TERMINATED）
            System.out.println("Thread State: " + thread.getState());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}