【并发】并发的基础概念（六）

在 Java 中，线程可以处于以下几种状态：

1. 新建 (New):

   • 线程对象已经创建，但尚未调用 start() 方法。
   • 代码示例：

     Thread t = new Thread(() -> {
         // 线程任务
     });
     

2. 就绪 (Runnable):

   • 线程已经调用了 start() 方法，等待线程调度器分配 CPU 时间。
   • 注意：这个状态包括了处于就绪状态和正在运行状态的线程。
   • 代码示例：

     t.start();
     

3. 运行 (Running):

   • 线程获得了 CPU 时间片，正在执行其 run() 方法的代码。
   • 这个状态是就绪状态的一个子状态，线程实际运行时才处于此状态。

4. 阻塞 (Blocked):

   • 线程因为等待某个锁而被阻塞。当另一个线程释放了这个锁时，线程会变成就绪状态。
   • 代码示例：

     synchronized (lock) {
         // 获取锁
     }
     

5. 等待 (Waiting):

   • 线程无限期地等待另一个线程显式地唤醒它。常见的场景是调用了 Object.wait() 方法。
   • 代码示例：

     synchronized (lock) {
         lock.wait(); // 线程进入等待状态
     }
     

6. 超时等待 (Timed Waiting):

   • 线程等待一段时间后会自动被唤醒。常见的场景是调用了 Thread.sleep(long millis)、Object.wait(long timeout)、Thread.join(long millis) 等方法。
   • 代码示例：

     try {
         Thread.sleep(1000); // 线程进入超时等待状态
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     

7. 终止 (Terminated):

   • 线程的 run() 方法执行完毕或者因为异常退出，线程进入终止状态。
   • 代码示例：

     public void run() {
         // 线程任务
         // 执行完毕后线程终止
     }
     

以下是一个示例代码，展示了线程的各种状态变化：

public class ThreadStateDemo {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000); // 进入超时等待状态
                synchronized (ThreadStateDemo.class) {
                    ThreadStateDemo.class.wait(); // 进入等待状态
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("Thread state after creation: " + t.getState()); // NEW

        t.start();
        System.out.println("Thread state after start: " + t.getState()); // RUNNABLE

        try {
            Thread.sleep(500);
            System.out.println("Thread state while sleeping: " + t.getState()); // TIMED_WAITING

            synchronized (ThreadStateDemo.class) {
                ThreadStateDemo.class.notify(); // 唤醒线程
            }

            Thread.sleep(500);
            System.out.println("Thread state after notify: " + t.getState()); // WAITING 或 RUNNABLE

            t.join();
            System.out.println("Thread state after join: " + t.getState()); // TERMINATED
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

此示例展示了线程在不同状态之间的转换过程。