快速入门多线程（一）：线程生命周期详解（附流程图详解）

线程的生命周期是多线程编程的核心概念之一，理解它能帮助你更好地控制线程行为，避免常见的并发问题。本文结合流程图、生活化比喻和代码示例来详细解析。

一、线程生命周期全景图

二、六大状态详解（JVM视角）

1. 新建状态（New）

• 定义：线程对象已创建（new Thread()），但尚未调用start()方法。
• 比喻：
  就像婴儿刚出生，还未开始活动。
• 代码：

  Thread t = new Thread(() -> System.out.println("线程运行中")); // 新建状态
  

2. 就绪状态（Runnable）

• 定义：线程已启动（调用start()），正在JVM中运行，但可能在等待操作系统分配CPU时间片。
• 比喻：
  运动员站在起跑线，已准备好但需等待裁判鸣枪。
• 关键点：
  • 线程进入就绪队列，由操作系统调度器决定何时执行。
  • start()方法只能调用一次，否则抛出IllegalThreadStateException。
• 代码：

  t.start(); // 进入就绪状态，等待CPU调度
  

3. 运行状态（Running）

• 定义：线程获得CPU时间片，正在执行run()方法中的代码。
• 比喻：
  运动员听到枪声开始奔跑。
• 关键点：
  • 线程可能因时间片用完或主动放弃CPU而回到就绪状态。
  • 多核CPU系统中，多个线程可同时处于运行状态。

4. 阻塞状态（Blocked）

• 定义：线程等待获取锁（如synchronized块）时的状态。
• 比喻：
  多人排队使用公共厕所，当前厕所有人占用，需等待。
• 代码示例：

  public class BlockedDemo {
      private static final Object LOCK = new Object();
      
      public static void main(String[] args) {
          Thread t1 = new Thread(() -> {
              synchronized (LOCK) {
                  try { Thread.sleep(1000); } catch (InterruptedException e) {}
              }
          });
          
          Thread t2 = new Thread(() -> {
              synchronized (LOCK) { // 若t1持有锁，t2进入Blocked状态
                  System.out.println("t2获取到锁");
              }
          });
          
          t1.start();
          t2.start();
      }
  }
  

5. 等待状态（Waiting）

• 定义：线程调用wait()、join()或LockSupport.park()后进入的状态，需显式唤醒。
• 比喻：
  顾客在餐厅等待服务员通知座位就绪。
• 代码示例：

  public class WaitingDemo {
      public static void main(String[] args) throws InterruptedException {
          Thread t = new Thread(() -> {
              synchronized (WaitingDemo.class) {
                  try {
                      WaitingDemo.class.wait(); // 进入Waiting状态
                  } catch (InterruptedException e) {}
              }
          });
          
          t.start();
          Thread.sleep(100);
          System.out.println("t的状态: " + t.getState()); // 输出WAITING
          
          synchronized (WaitingDemo.class) {
              WaitingDemo.class.notify(); // 唤醒线程
          }
      }
  }
  

6. 超时等待状态（Timed Waiting）

• 定义：线程调用Thread.sleep()、wait(timeout)、join(timeout)等带超时参数的方法后进入的状态。
• 比喻：
  顾客设定了等待餐厅座位的最长时间，超时后自行离开。
• 代码示例：

  public class TimedWaitingDemo {
      public static void main(String[] args) throws InterruptedException {
          Thread t = new Thread(() -> {
              try {
                  Thread.sleep(2000); // 进入Timed Waiting状态2秒
              } catch (InterruptedException e) {}
          });
          
          t.start();
          Thread.sleep(100);
          System.out.println("t的状态: " + t.getState()); // 输出TIMED_WAITING
      }
  }
  

7. 死亡状态（Terminated）

• 定义：线程执行完毕（run()方法正常返回）或因未捕获的异常终止。
• 比喻：
  运动员完成比赛或中途退赛。
• 关键点：
  • 死亡状态的线程无法重新启动，需创建新线程。
• 代码示例：

  Thread t = new Thread(() -> System.out.println("线程运行中"));
  t.start();
  Thread.sleep(100); // 等待线程执行完毕
  System.out.println("t的状态: " + t.getState()); // 输出TERMINATED
  

三、状态转换核心方法

四、线程生命周期完整示例

public class ThreadLifeCycleDemo {
    public static void main(String[] args) throws InterruptedException {
        // 1. 新建状态
        Thread t = new Thread(() -> {
            System.out.println("线程进入运行状态");
            
            // 3. 超时等待状态（sleep）
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            // 4. 阻塞状态（等待锁）
            synchronized (ThreadLifeCycleDemo.class) {
                try {
                    // 5. 等待状态（wait）
                    ThreadLifeCycleDemo.class.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            
            System.out.println("线程即将结束");
        });
        
        // 2. 就绪状态
        t.start();
        System.out.println("线程启动后状态: " + t.getState()); // RUNNABLE
        
        // 主线程休眠，让子线程有机会执行
        Thread.sleep(200);
        System.out.println("子线程sleep时状态: " + t.getState()); // TIMED_WAITING
        
        // 等待子线程进入wait状态
        Thread.sleep(1200);
        System.out.println("子线程wait时状态: " + t.getState()); // WAITING
        
        // 唤醒子线程
        synchronized (ThreadLifeCycleDemo.class) {
            ThreadLifeCycleDemo.class.notify();
        }
        
        // 等待子线程执行完毕
        t.join();
        System.out.println("子线程结束后状态: " + t.getState()); // TERMINATED
    }
}

五、常见问题与注意事项

1. 线程复用问题：
   死亡状态的线程无法重启，需避免重复调用start()。

2. 阻塞与忙等待：
   阻塞状态（如sleep()、wait()）会释放CPU资源，而忙等待（如while(true)）会持续占用CPU。

3. 线程安全：
   多线程在状态转换过程中可能出现竞态条件，需使用synchronized、Lock或原子类保护共享资源。

4. 中断机制：
   使用interrupt()优雅地终止线程，而非强制终止（stop()已被弃用）。

   Thread t = new Thread(() -> {
       while (!Thread.currentThread().isInterrupted()) {
           // 执行任务
       }
   });
   t.start();
   t.interrupt(); // 中断线程
   

六、总结

线程的生命周期就像一场精心编排的舞蹈：

• 新建：舞者站到舞台一侧（创建线程对象）。
• 就绪：等待音乐响起（等待CPU调度）。
• 运行：尽情舞蹈（执行代码）。
• 阻塞：暂停动作等待道具（等待资源）。
• 等待：定格姿势等待提示（等待通知）。
• 超时等待：按预定时间暂停（超时自动恢复）。
• 死亡：舞蹈结束谢幕（执行完成）。

理解每个状态的转换条件和对应的方法，方便我们能更精准地控制线程行为，编写出高效、稳定的并发程序。