学习目标

  • 了解Java线程的六大状态及其转换过程
  • 掌握线程状态的判断和监控方法
  • 理解如何合理地控制线程状态转换
  • 学会识别和解决线程卡死的常见问题

1. 线程的六大状态：NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED

在Java中，线程的生命周期被划分为六种状态，这些状态定义在Thread.State枚举类中。理解这些状态及其转换对于开发高效的多线程应用至关重要。

1.1 NEW（新建）

当线程对象被创建但还未调用start()方法时，线程处于NEW状态。

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 演示线程的NEW状态
  5.  */
  6. public class ThreadNewStateDemo {
  7.     public static void main(String[] args) {
  8.         // 创建线程对象，此时线程处于NEW状态
  9.         Thread thread = new Thread(() -> {
  10.             System.out.println("线程执行中...");
  11.         });
  13.         // 检查线程状态
  14.         System.out.println("线程创建后的状态: " + thread.getState());
  16.         // 验证是否为NEW状态
  17.         System.out.println("是否为NEW状态: " + (thread.getState() == Thread.State.NEW));
  18.     }
  19. }

1.2 RUNNABLE（可运行）

当线程调用了start()方法后，它的状态变为RUNNABLE。这表示线程已经被启动，正在等待被线程调度器分配CPU时间片。

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 演示线程的RUNNABLE状态
  5.  */
  6. public class ThreadRunnableStateDemo {
  7.     public static void main(String[] args) {
  8.         Thread thread = new Thread(() -> {
  9.             // 一个长时间运行的任务，确保线程保持RUNNABLE状态
  10.             for (long i = 0; i < 1_000_000_000L; i++) {
  11.                 // 执行一些计算，让线程保持活动状态
  12.                 Math.sqrt(i);
  13.             }
  14.         });
  16.         // 启动线程，状态从NEW变为RUNNABLE
  17.         thread.start();
  19.         // 给线程一点时间启动
  20.         try {
  21.             Thread.sleep(10);
  22.         } catch (InterruptedException e) {
  23.             e.printStackTrace();
  24.         }
  26.         // 检查线程状态
  27.         System.out.println("线程启动后的状态: " + thread.getState());
  29.         // 等待线程结束
  30.         try {
  31.             thread.join();
  32.         } catch (InterruptedException e) {
  33.             e.printStackTrace();
  34.         }
  35.     }
  36. }

1.3 BLOCKED（阻塞）

当线程尝试获取一个被其他线程持有的对象锁时，该线程会进入BLOCKED状态。线程会一直保持BLOCKED状态，直到它获得了锁。

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 演示线程的BLOCKED状态
  5.  */
  6. public class ThreadBlockedStateDemo {
  8.     // 共享资源，用于线程同步
  9.     private static final Object lock = new Object();
  11.     public static void main(String[] args) {
  12.         // 创建第一个线程，它会获取并持有锁
  13.         Thread thread1 = new Thread(() -> {
  14.             System.out.println("线程1开始执行");
  15.             synchronized (lock) {
  16.                 // 持有锁10秒钟
  17.                 System.out.println("线程1获取到锁");
  18.                 try {
  19.                     Thread.sleep(10000);
  20.                 } catch (InterruptedException e) {
  21.                     e.printStackTrace();
  22.                 }
  23.                 System.out.println("线程1释放锁");
  24.             }
  25.         });
  27.         // 创建第二个线程，它会尝试获取锁但会被阻塞
  28.         Thread thread2 = new Thread(() -> {
  29.             System.out.println("线程2开始执行");
  30.             synchronized (lock) {
  31.                 // 如果获取到锁，则执行这里的代码
  32.                 System.out.println("线程2获取到锁");
  33.             }
  34.         });
  36.         // 启动第一个线程
  37.         thread1.start();
  39.         // 给线程1一点时间获取锁
  40.         try {
  41.             Thread.sleep(100);
  42.         } catch (InterruptedException e) {
  43.             e.printStackTrace();
  44.         }
  46.         // 启动第二个线程
  47.         thread2.start();
  49.         // 给线程2一点时间尝试获取锁
  50.         try {
  51.             Thread.sleep(100);
  52.         } catch (InterruptedException e) {
  53.             e.printStackTrace();
  54.         }
  56.         // 检查线程2的状态
  57.         System.out.println("线程2的状态: " + thread2.getState());
  59.         // 等待两个线程都结束
  60.         try {
  61.             thread1.join();
  62.             thread2.join();
  63.         } catch (InterruptedException e) {
  64.             e.printStackTrace();
  65.         }
  66.     }
  67. }

1.4 WAITING（等待）

当线程调用某些方法主动放弃CPU执行权，进入无限期等待状态时，线程处于WAITING状态。以下方法可以导致线程进入WAITING状态：

  • Object.wait()：等待其他线程调用同一对象的notify()或notifyAll()
  • Thread.join()：等待指定的线程结束
  • LockSupport.park()：等待许可
  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 演示线程的WAITING状态
  5.  */
  6. public class ThreadWaitingStateDemo {
  8.     private static final Object lock = new Object();
  10.     public static void main(String[] args) {
  11.         // 创建等待线程
  12.         Thread waitingThread = new Thread(() -> {
  13.             synchronized (lock) {
  14.                 try {
  15.                     System.out.println("等待线程进入等待状态...");
  16.                     lock.wait(); // 调用wait()方法，线程进入WAITING状态
  17.                     System.out.println("等待线程被唤醒，继续执行");
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.             }
  22.         });
  24.         // 创建唤醒线程
  25.         Thread notifyThread = new Thread(() -> {
  26.             try {
  27.                 // 先休眠2秒，确保waitingThread已经进入WAITING状态
  28.                 Thread.sleep(2000);
  30.                 synchronized (lock) {
  31.                     System.out.println("唤醒线程准备唤醒等待线程...");
  32.                     lock.notify(); // 唤醒在lock上等待的线程
  33.                     System.out.println("唤醒线程已发出唤醒信号");
  34.                 }
  35.             } catch (InterruptedException e) {
  36.                 e.printStackTrace();
  37.             }
  38.         });
  40.         // 启动等待线程
  41.         waitingThread.start();
  43.         // 给等待线程一点时间进入等待状态
  44.         try {
  45.             Thread.sleep(500);
  46.         } catch (InterruptedException e) {
  47.             e.printStackTrace();
  48.         }
  50.         // 检查等待线程的状态
  51.         System.out.println("等待线程的状态: " + waitingThread.getState());
  53.         // 启动唤醒线程
  54.         notifyThread.start();
  56.         // 等待两个线程结束
  57.         try {
  58.             waitingThread.join();
  59.             notifyThread.join();
  60.         } catch (InterruptedException e) {
  61.             e.printStackTrace();
  62.         }
  63.     }
  64. }

1.5 TIMED_WAITING（限时等待）

当线程调用带有超时参数的方法主动放弃CPU执行权，进入有限期等待状态时，线程处于TIMED_WAITING状态。以下方法可以导致线程进入TIMED_WAITING状态：

  • Thread.sleep(long millis)：休眠指定的毫秒数
  • Object.wait(long timeout)：等待指定的毫秒数，或者直到被通知
  • Thread.join(long millis)：等待指定线程结束，但最多等待指定的毫秒数
  • LockSupport.parkNanos(long nanos)：等待许可，但最多等待指定的纳秒数
  • LockSupport.parkUntil(long deadline)：等待许可，但最多等待到指定的时间戳
  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 演示线程的TIMED_WAITING状态
  5.  */
  6. public class ThreadTimedWaitingStateDemo {
  7.     public static void main(String[] args) {
  8.         Thread sleepingThread = new Thread(() -> {
  9.             try {
  10.                 System.out.println("线程开始休眠5秒...");
  11.                 Thread.sleep(5000); // 线程休眠5秒，进入TIMED_WAITING状态
  12.                 System.out.println("线程休眠结束");
  13.             } catch (InterruptedException e) {
  14.                 System.out.println("线程被中断");
  15.             }
  16.         });
  18.         // 启动线程
  19.         sleepingThread.start();
  21.         // 给线程一点时间进入休眠状态
  22.         try {
  23.             Thread.sleep(100);
  24.         } catch (InterruptedException e) {
  25.             e.printStackTrace();
  26.         }
  28.         // 检查线程状态
  29.         System.out.println("休眠线程的状态: " + sleepingThread.getState());
  31.         // 等待线程结束
  32.         try {
  33.             sleepingThread.join();
  34.         } catch (InterruptedException e) {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38. }

1.6 TERMINATED（终止）

当线程正常结束或因异常而结束时，线程进入TERMINATED状态。

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 演示线程的TERMINATED状态
  5.  */
  6. public class ThreadTerminatedStateDemo {
  7.     public static void main(String[] args) {
  8.         Thread thread = new Thread(() -> {
  9.             System.out.println("线程开始执行...");
  10.             // 执行一些简单的任务后结束
  11.             for (int i = 0; i < 5; i++) {
  12.                 System.out.println("线程执行中: " + i);
  13.                 try {
  14.                     Thread.sleep(200);
  15.                 } catch (InterruptedException e) {
  16.                     e.printStackTrace();
  17.                 }
  18.             }
  19.             System.out.println("线程执行结束");
  20.         });
  22.         // 启动线程
  23.         thread.start();
  25.         // 等待线程执行完毕
  26.         try {
  27.             thread.join();
  28.         } catch (InterruptedException e) {
  29.             e.printStackTrace();
  30.         }
  32.         // 检查线程状态
  33.         System.out.println("线程的状态: " + thread.getState());
  35.         // 验证是否为TERMINATED状态
  36.         System.out.println("是否为TERMINATED状态: " + (thread.getState() == Thread.State.TERMINATED));
  37.     }
  38. }

2. 状态转换图解与示例代码

线程在其生命周期中可以在不同状态之间转换。下面是一个Java线程状态转换图，它展示了各状态之间可能的转换路径：

  1.     +--------------------+
  2.     |      NEW           |
  3.     +--------------------+
  4.               |
  5.               | start()
  6.               v
  7.     +--------------------+
  8.     |     RUNNABLE       |<---+
  9.     +--------------------+    |
  10.         |     ^     |         |
  11.         |     |     |         | 获取到锁/唤醒/超时
  12.         |     |     |         |
  13.         |     |     v         |
  14.         |  +--------------------+
  15.         |  |     BLOCKED       |
  16.         |  +--------------------+
  17.         |          
  18.         |   获取锁失败
  19.         |
  20.         |
  21.         |   wait()/join()
  22.         v
  23.     +--------------------+
  24.     |     WAITING        |--------+
  25.     +--------------------+        |
  26.               |                   |
  27.               | notify()/notifyAll()  |
  28.               |                   |
  29.               v                   |
  30.     +--------------------+        |
  31.     |  TIMED_WAITING     |<-------+
  32.     +--------------------+  wait(timeout)/
  33.               |             sleep(timeout)/
  34.               | 超时         join(timeout)
  35.               |
  36.               v
  37.     +--------------------+
  38.     |    TERMINATED      |
  39.     +--------------------+

让我们创建一个综合示例，展示线程在其生命周期中如何在不同状态之间转换：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. import java.util.concurrent.TimeUnit;
  5. /**
  6.  * 线程状态转换综合示例
  7.  */
  8. public class ThreadStateTransitionDemo {
  10.     // 共享锁对象
  11.     private static final Object lock = new Object();
  13.     // 标记是否应该等待
  14.     private static boolean shouldWait = true;
  16.     public static void main(String[] args) throws InterruptedException {
  17.         // 创建线程，该线程会经历所有可能的状态
  18.         Thread thread = new Thread(() -> {
  19.             System.out.println("线程开始执行...");
  21.             // 进入RUNNABLE状态的一些计算
  22.             System.out.println("执行一些计算...");
  23.             for (int i = 0; i < 1000000; i++) {
  24.                 Math.sqrt(i);
  25.             }
  27.             synchronized (lock) {
  28.                 // 进入条件等待
  29.                 if (shouldWait) {
  30.                     try {
  31.                         System.out.println("线程即将进入WAITING状态...");
  32.                         lock.wait(); // 这会导致线程进入WAITING状态
  33.                         System.out.println("线程从WAITING状态被唤醒！");
  34.                     } catch (InterruptedException e) {
  35.                         e.printStackTrace();
  36.                     }
  37.                 }
  39.                 // 执行受锁保护的代码
  40.                 System.out.println("执行受锁保护的代码");
  41.             }
  43.             // 进入TIMED_WAITING状态
  44.             try {
  45.                 System.out.println("线程即将进入TIMED_WAITING状态...");
  46.                 TimeUnit.SECONDS.sleep(2); // 休眠2秒，进入TIMED_WAITING状态
  47.                 System.out.println("线程从TIMED_WAITING状态恢复");
  48.             } catch (InterruptedException e) {
  49.                 e.printStackTrace();
  50.             }
  52.             System.out.println("线程执行完毕，即将进入TERMINATED状态");
  53.         });
  55.         // 打印线程的初始状态（NEW）
  56.         System.out.println("1. 初始状态: " + thread.getState());
  58.         // 启动线程
  59.         thread.start();
  60.         System.out.println("2. 调用start()后: " + thread.getState());
  62.         // 给线程一点时间运行
  63.         TimeUnit.MILLISECONDS.sleep(100);
  64.         System.out.println("3. 线程运行中: " + thread.getState());
  66.         // 线程应该已经进入WAITING状态
  67.         TimeUnit.SECONDS.sleep(1);
  68.         System.out.println("4. 线程应该在等待: " + thread.getState());
  70.         // 在锁上调用notify，唤醒等待的线程
  71.         synchronized (lock) {
  72.             System.out.println("主线程获取到锁，准备唤醒等待的线程");
  73.             shouldWait = false;
  74.             lock.notify();
  75.         }
  77.         // 给线程一点时间执行并进入TIMED_WAITING状态
  78.         TimeUnit.MILLISECONDS.sleep(500);
  79.         System.out.println("5. 线程应该在限时等待: " + thread.getState());
  81.         // 等待线程执行完毕
  82.         thread.join();
  83.         System.out.println("6. 线程执行完毕: " + thread.getState());
  84.     }
  85. }

运行这个示例，你将看到线程经历从NEW到RUNNABLE，然后到WAITING，然后回到RUNNABLE，再到TIMED_WAITING，最后到TERMINATED的完整生命周期过程。

📌 提示： 使用Thread.getState()方法可以获取线程的当前状态，但由于线程状态可能随时变化，因此获取到的状态可能已经过时。这个方法主要用于调试和监控。

3. 多线程执行障碍分析与解决

在多线程程序中，线程卡死（线程无法继续执行但也没有终止）是一种常见的问题。了解线程卡死的常见原因及其解决方案非常重要。

3.1 死锁（Deadlock）

问题描述： 死锁是指两个或多个线程互相等待对方持有的锁，导致所有线程都无法继续执行的情况。

示例代码：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 死锁示例
  5.  */
  6. public class DeadlockDemo {
  7.     // 两个共享资源
  8.     private static final Object resource1 = new Object();
  9.     private static final Object resource2 = new Object();
  11.     public static void main(String[] args) {
  12.         // 创建第一个线程，先获取resource1，再获取resource2
  13.         Thread thread1 = new Thread(() -> {
  14.             System.out.println("线程1尝试获取resource1...");
  15.             synchronized (resource1) {
  16.                 System.out.println("线程1获取到resource1");
  18.                 // 让线程休眠一会儿，确保线程2有时间获取resource2
  19.                 try {
  20.                     Thread.sleep(100);
  21.                 } catch (InterruptedException e) {
  22.                     e.printStackTrace();
  23.                 }
  25.                 System.out.println("线程1尝试获取resource2...");
  26.                 synchronized (resource2) {
  27.                     System.out.println("线程1同时获取到resource1和resource2");
  28.                 }
  29.             }
  30.         });
  32.         // 创建第二个线程，先获取resource2，再获取resource1
  33.         Thread thread2 = new Thread(() -> {
  34.             System.out.println("线程2尝试获取resource2...");
  35.             synchronized (resource2) {
  36.                 System.out.println("线程2获取到resource2");
  38.                 // 让线程休眠一会儿，确保线程1有时间获取resource1
  39.                 try {
  40.                     Thread.sleep(100);
  41.                 } catch (InterruptedException e) {
  42.                     e.printStackTrace();
  43.                 }
  45.                 System.out.println("线程2尝试获取resource1...");
  46.                 synchronized (resource1) {
  47.                     System.out.println("线程2同时获取到resource1和resource2");
  48.                 }
  49.             }
  50.         });
  52.         // 启动线程
  53.         thread1.start();
  54.         thread2.start();
  55.     }
  56. }

产生原因： 死锁通常由以下因素共同导致：

  1. 互斥：资源只能被一个线程占用
  2. 请求与保持：线程在等待资源时不释放已有资源
  3. 不可剥夺：资源只能由持有者自愿释放
  4. 循环等待：存在一个线程等待链

解决方案：

  1. 按顺序获取锁： 确保所有线程按照相同的顺序获取锁，可以避免循环等待
  2. 使用超时： 使用tryLock(timeout)等方法设置获取锁的超时时间
  3. 死锁检测： 使用工具（如JConsole、jstack）检测死锁
  4. 使用更高级的并发工具： 如java.util.concurrent包中的工具

3.2 活锁（Livelock）

问题描述： 活锁是指线程一直在运行，但是无法向前推进，通常是因为线程互相礼让导致的。

示例代码：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 活锁示例
  5.  */
  6. public class LivelockDemo {
  8.     static class Worker {
  9.         private String name;
  10.         private boolean active;
  12.         public Worker(String name, boolean active) {
  13.             this.name = name;
  14.             this.active = active;
  15.         }
  17.         public String getName() {
  18.             return name;
  19.         }
  21.         public boolean isActive() {
  22.             return active;
  23.         }
  25.         public void work(Worker otherWorker, Object commonResource) {
  26.             while (active) {
  27.                 // 如果其他工作者处于活动状态，则礼让
  28.                 if (otherWorker.isActive()) {
  29.                     System.out.println(name + ": " + otherWorker.getName() + " 正在工作，我稍后再试");
  30.                     active = false;
  31.                     // 主动礼让CPU，让其他线程有机会运行
  32.                     Thread.yield();
  33.                     // 过一会儿，重新尝试工作
  34.                     try {
  35.                         Thread.sleep(100);
  36.                     } catch (InterruptedException e) {
  37.                         e.printStackTrace();
  38.                     }
  39.                     active = true;
  40.                     continue;
  41.                 }
  43.                 // 如果其他工作者不活动，则使用共享资源
  44.                 System.out.println(name + ": 使用共享资源");
  45.                 active = false;
  46.                 // 工作完成，退出循环
  47.                 break;
  48.             }
  49.         }
  50.     }
  52.     public static void main(String[] args) {
  53.         final Worker worker1 = new Worker("工作者1", true);
  54.         final Worker worker2 = new Worker("工作者2", true);
  55.         final Object commonResource = new Object();
  57.         new Thread(() -> {
  58.             worker1.work(worker2, commonResource);
  59.         }).start();
  61.         new Thread(() -> {
  62.             worker2.work(worker1, commonResource);
  63.         }).start();
  64.     }
  65. }

产生原因： 活锁通常是由于线程过度谦让或反应过度调整导致的。

解决方案：

  1. 增加随机性： 在重试机制中加入随机延迟
  2. 优先级调整： 调整线程优先级，避免线程互相礼让
  3. 使用锁超时： 设置锁获取的超时机制

3.3 饥饿（Starvation）

问题描述： 饥饿是指线程因无法获取所需资源而长时间无法执行的情况。

示例代码：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. /**
  4.  * 线程饥饿示例
  5.  */
  6. public class StarvationDemo {
  8.     private static Object sharedResource = new Object();
  10.     public static void main(String[] args) {
  11.         // 创建5个高优先级线程，它们会反复获取共享资源
  12.         for (int i = 0; i < 5; i++) {
  13.             Thread highPriorityThread = new Thread(() -> {
  14.                 while (true) {
  15.                     synchronized (sharedResource) {
  16.                         // 高优先级线程持有锁时的操作
  17.                         try {
  18.                             Thread.sleep(200);
  19.                         } catch (InterruptedException e) {
  20.                             e.printStackTrace();
  21.                         }
  22.                     }
  23.                 }
  24.             });
  25.             highPriorityThread.setPriority(Thread.MAX_PRIORITY);
  26.             highPriorityThread.start();
  27.         }
  29.         // 创建一个低优先级线程，它很难获取到共享资源
  30.         Thread lowPriorityThread = new Thread(() -> {
  31.             while (true) {
  32.                 synchronized (sharedResource) {
  33.                     System.out.println("低优先级线程终于获取到了锁！");
  34.                     // 低优先级线程持有锁时的操作
  35.                     try {
  36.                         Thread.sleep(100);
  37.                     } catch (InterruptedException e) {
  38.                         e.printStackTrace();
  39.                     }
  40.                 }
  41.             }
  42.         });
  43.         lowPriorityThread.setPriority(Thread.MIN_PRIORITY);
  44.         lowPriorityThread.start();
  45.     }
  46. }

产生原因： 饥饿通常是由于资源分配不公平或线程优先级设置不合理导致的。

解决方案：

  1. 公平锁： 使用公平锁（如ReentrantLock(true)）确保先到先得
  2. 合理设置优先级： 避免过大的优先级差异
  3. 资源限制： 限制高优先级线程对资源的占用时间

3.4 线程泄漏（Thread Leak）

问题描述： 线程泄漏是指创建的线程没有被正确终止或回收，导致系统资源被持续占用的情况。

示例代码：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. import java.util.concurrent.ExecutorService;
  4. import java.util.concurrent.Executors;
  6. /**
  7.  * 线程泄漏示例
  8.  */
  9. public class ThreadLeakDemo {
  11.     public static void main(String[] args) {
  12.         // 错误的线程池使用方式，没有关闭线程池
  13.         badThreadPoolUsage();
  15.         // 正确的线程池使用方式
  16.         goodThreadPoolUsage();
  17.     }
  19.     private static void badThreadPoolUsage() {
  20.         System.out.println("=== 错误的线程池使用方式 ===");
  21.         // 创建一个固定大小的线程池
  22.         ExecutorService executor = Executors.newFixedThreadPool(5);
  24.         // 提交任务
  25.         for (int i = 0; i < 10; i++) {
  26.             final int taskId = i;
  27.             executor.submit(() -> {
  28.                 System.out.println("执行任务 " + taskId);
  29.                 return taskId;
  30.             });
  31.         }
  33.         // 没有调用shutdown()方法，线程池中的线程会一直存在
  34.         System.out.println("任务提交完毕，但线程池没有被关闭");
  35.     }
  37.     private static void goodThreadPoolUsage() {
  38.         System.out.println("=== 正确的线程池使用方式 ===");
  39.         // 创建一个固定大小的线程池
  40.         ExecutorService executor = Executors.newFixedThreadPool(5);
  42.         try {
  43.             // 提交任务
  44.             for (int i = 0; i < 10; i++) {
  45.                 final int taskId = i;
  46.                 executor.submit(() -> {
  47.                     System.out.println("执行任务 " + taskId);
  48.                     return taskId;
  49.                 });
  50.             }
  51.         } finally {
  52.             // 确保线程池被关闭
  53.             executor.shutdown();
  54.             System.out.println("任务提交完毕，线程池已关闭");
  55.         }
  56.     }
  57. }

产生原因： 线程泄漏通常是由于未正确关闭线程池、忘记等待线程结束或线程被卡在无限循环中导致的。

解决方案：

  1. 正确关闭线程池： 使用shutdown()或shutdownNow()方法关闭线程池
  2. 使用try-finally块： 确保即使出现异常，资源也能被正确释放
  3. 设置超时机制： 为长时间运行的任务设置超时机制

4. 实战案例：线程状态监控工具

现在，让我们将所学知识应用到一个实际案例中。下面是一个简单的线程状态监控工具，可以定期打印指定线程的状态：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. import java.util.Map;
  4. import java.util.concurrent.ConcurrentHashMap;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.ScheduledExecutorService;
  7. import java.util.concurrent.TimeUnit;
  9. /**
  10.  * 线程状态监控工具
  11.  */
  12. public class ThreadMonitor {
  14.     // 存储要监控的线程
  15.     private final Map<String, Thread> monitoredThreads = new ConcurrentHashMap<>();
  17.     // 用于执行定期监控任务的调度器
  18.     private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
  20.     // 监控时间间隔（秒）
  21.     private final int monitorInterval;
  23.     // 是否正在监控
  24.     private boolean monitoring = false;
  26.     /**
  27.      * 创建线程监控器
  28.      * @param monitorInterval 监控间隔（秒）
  29.      */
  30.     public ThreadMonitor(int monitorInterval) {
  31.         this.monitorInterval = monitorInterval;
  32.     }
  34.     /**
  35.      * 添加要监控的线程
  36.      * @param name 线程名称
  37.      * @param thread 线程对象
  38.      */
  39.     public void addThread(String name, Thread thread) {
  40.         monitoredThreads.put(name, thread);
  41.         System.out.println("添加线程 '" + name + "' 到监控列表");
  42.     }
  44.     /**
  45.      * 移除监控的线程
  46.      * @param name 线程名称
  47.      */
  48.     public void removeThread(String name) {
  49.         monitoredThreads.remove(name);
  50.         System.out.println("从监控列表中移除线程 '" + name + "'");
  51.     }
  53.     /**
  54.      * 开始监控
  55.      */
  56.     public void startMonitoring() {
  57.         if (monitoring) {
  58.             System.out.println("监控已经在运行中");
  59.             return;
  60.         }
  62.         monitoring = true;
  64.         // 创建并调度监控任务
  65.         scheduler.scheduleAtFixedRate(() -> {
  66.             System.out.println("\n=== 线程状态监控报告 ===");
  67.             System.out.println("时间: " + System.currentTimeMillis());
  68.             System.out.println("监控的线程数量: " + monitoredThreads.size());
  70.             // 打印每个线程的状态
  71.             monitoredThreads.forEach((name, thread) -> {
  72.                 Thread.State state = thread.getState();
  73.                 String statusInfo = String.format("线程 '%s' (ID: %d) - 状态: %s",
  74.                         name, thread.getId(), state);
  76.                 // 根据状态提供额外信息
  77.                 switch (state) {
  78.                     case BLOCKED:
  79.                         statusInfo += " - 等待获取监视器锁";
  80.                         break;
  81.                     case WAITING:
  82.                         statusInfo += " - 无限期等待另一个线程执行特定操作";
  83.                         break;
  84.                     case TIMED_WAITING:
  85.                         statusInfo += " - 等待另一个线程执行操作，最多等待指定的时间";
  86.                         break;
  87.                     case TERMINATED:
  88.                         statusInfo += " - 线程已结束执行";
  89.                         break;
  90.                 }
  92.                 System.out.println(statusInfo);
  93.             });
  95.             // 清理已终止的线程
  96.             monitoredThreads.entrySet().removeIf(entry -> 
  97.                     entry.getValue().getState() == Thread.State.TERMINATED);
  99.             System.out.println("===========================");
  100.         }, 0, monitorInterval, TimeUnit.SECONDS);
  102.         System.out.println("开始监控线程状态，间隔: " + monitorInterval + " 秒");
  103.     }
  105.     /**
  106.      * 停止监控
  107.      */
  108.     public void stopMonitoring() {
  109.         monitoring = false;
  110.         scheduler.shutdown();
  111.         System.out.println("停止线程状态监控");
  112.     }
  113. }

现在，让我们使用这个监控工具来监控不同状态的线程：

  1. package org.devlive.tutorial.multithreading.chapter02;
  3. import java.util.concurrent.CountDownLatch;
  4. import java.util.concurrent.TimeUnit;
  6. /**
  7.  * 线程监控工具使用示例
  8.  */
  9. public class ThreadMonitorDemo {
  11.     // 共享锁对象
  12.     private static final Object lock = new Object();
  14.     // 用于协调线程的CountDownLatch
  15.     private static final CountDownLatch latch = new CountDownLatch(1);
  17.     public static void main(String[] args) {
  18.         // 创建线程监控器，每2秒监控一次
  19.         ThreadMonitor monitor = new ThreadMonitor(2);
  21.         // 创建几个用于演示不同状态的线程
  23.         // 1. 创建一个长时间运行的线程
  24.         Thread runningThread = new Thread(() -> {
  25.             System.out.println("长时间运行的线程开始执行");
  26.             long sum = 0;
  27.             for (long i = 0; i < 10_000_000_000L; i++) {
  28.                 sum += i;
  29.                 if (i % 1_000_000_000 == 0) {
  30.                     System.out.println("计算中: " + i / 1_000_000_000);
  31.                 }
  32.             }
  33.             System.out.println("长时间运行的线程计算结果: " + sum);
  34.         });
  36.         // 2. 创建一个会进入WAITING状态的线程
  37.         Thread waitingThread = new Thread(() -> {
  38.             try {
  39.                 System.out.println("等待线程开始执行");
  40.                 latch.await(); // 等待主线程计数器减为0
  41.                 System.out.println("等待线程继续执行");
  42.             } catch (InterruptedException e) {
  43.                 e.printStackTrace();
  44.             }
  45.         });
  47.         // 3. 创建一个会进入TIMED_WAITING状态的线程
  48.         Thread sleepingThread = new Thread(() -> {
  49.             try {
  50.                 System.out.println("休眠线程开始执行");
  51.                 Thread.sleep(20000); // 休眠20秒
  52.                 System.out.println("休眠线程醒来继续执行");
  53.             } catch (InterruptedException e) {
  54.                 e.printStackTrace();
  55.             }
  56.         });
  58.         // 4. 创建一个会进入BLOCKED状态的线程
  59.         Thread blockedThread = new Thread(() -> {
  60.             System.out.println("阻塞线程开始执行，等待获取锁");
  61.             synchronized (lock) {
  62.                 System.out.println("阻塞线程获取到锁");
  63.             }
  64.         });
  66.         // 主线程先获取锁，让blockedThread进入BLOCKED状态
  67.         synchronized (lock) {
  68.             // 添加线程到监控器
  69.             monitor.addThread("运行线程", runningThread);
  70.             monitor.addThread("等待线程", waitingThread);
  71.             monitor.addThread("休眠线程", sleepingThread);
  72.             monitor.addThread("阻塞线程", blockedThread);
  74.             // 启动线程
  75.             runningThread.start();
  76.             waitingThread.start();
  77.             sleepingThread.start();
  78.             blockedThread.start();
  80.             // 开始监控
  81.             monitor.startMonitoring();
  83.             // 主线程持有锁10秒钟，让blockedThread保持BLOCKED状态
  84.             try {
  85.                 System.out.println("主线程持有锁10秒钟，blockedThread将保持BLOCKED状态");
  86.                 TimeUnit.SECONDS.sleep(10);
  87.             } catch (InterruptedException e) {
  88.                 e.printStackTrace();
  89.             }
  91.             System.out.println("主线程释放锁，blockedThread将获取锁并继续执行");
  92.         }
  94.         // 5秒后释放等待线程
  95.         try {
  96.             TimeUnit.SECONDS.sleep(5);
  97.             System.out.println("主线程释放等待线程");
  98.             latch.countDown();
  99.         } catch (InterruptedException e) {
  100.             e.printStackTrace();
  101.         }
  103.         // 等待所有线程结束
  104.         try {
  105.             runningThread.join();
  106.             waitingThread.join();
  107.             sleepingThread.join();
  108.             blockedThread.join();
  109.         } catch (InterruptedException e) {
  110.             e.printStackTrace();
  111.         }
  113.         // 停止监控
  114.         monitor.stopMonitoring();
  115.     }
  116. }

这个实战案例展示了如何创建一个工具来监控线程的状态变化，这对于调试复杂的多线程应用非常有用。

常见问题与解决方案

问题1：如何正确终止一个线程？

问题描述： Java中没有安全的方法可以直接强制终止一个线程。Thread.stop()、Thread.suspend()和Thread.resume()方法已被弃用，因为它们可能导致数据不一致。

解决方案： 使用中断机制实现线程的协作终止：

  1. public class GracefulThreadTermination {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         // 创建一个能响应中断的线程
  4.         Thread thread = new Thread(() -> {
  5.             // 检查中断标志
  6.             while (!Thread.currentThread().isInterrupted()) {
  7.                 try {
  8.                     // 执行任务...
  9.                     System.out.println("线程执行中...");
  10.                     Thread.sleep(1000);
  11.                 } catch (InterruptedException e) {
  12.                     // 捕获中断异常，重新设置中断标志，并退出循环
  13.                     System.out.println("线程被中断，准备清理资源并退出");
  14.                     Thread.currentThread().interrupt();
  15.                     break;
  16.                 }
  17.             }
  19.             // 线程结束前的清理工作
  20.             System.out.println("线程正在清理资源...");
  21.             System.out.println("线程已安全终止");
  22.         });
  24.         thread.start();
  26.         // 主线程休眠3秒
  27.         Thread.sleep(3000);
  29.         // 中断线程
  30.         System.out.println("主线程发送中断信号");
  31.         thread.interrupt();
  32.     }
  33. }

问题2：如何解决死锁？

问题描述： 死锁是多线程编程中的常见问题，一旦发生很难恢复。

解决方案：

  1. 预防死锁： 按固定顺序获取锁

    1. // 正确的获取多个锁的方式
    2. public void transferMoney(Account fromAccount, Account toAccount, double amount) {
    3.     // 确保按账户ID的顺序获取锁
    4.     Account firstLock = fromAccount.getId() < toAccount.getId() ? fromAccount : toAccount;
    5.     Account secondLock = fromAccount.getId() < toAccount.getId() ? toAccount : fromAccount;
    7.     synchronized (firstLock) {
    8.         synchronized (secondLock) {
    9.             // 执行转账逻辑
    10.         }
    11.     }
    12. }

  2. 使用tryLock带超时的锁获取：

    1. Lock lock1 = new ReentrantLock();
    2. Lock lock2 = new ReentrantLock();
    4. public void doSomething() {
    5.     boolean gotFirstLock = false;
    6.     boolean gotSecondLock = false;
    8.     try {
    9.         gotFirstLock = lock1.tryLock(1, TimeUnit.SECONDS);
    10.         if (gotFirstLock) {
    11.             gotSecondLock = lock2.tryLock(1, TimeUnit.SECONDS);
    12.         }
    14.         if (gotFirstLock && gotSecondLock) {
    15.             // 成功获取两个锁，执行操作
    16.         } else {
    17.             // 无法获取锁，放弃本次操作
    18.         }
    19.     } catch (InterruptedException e) {
    20.         Thread.currentThread().interrupt();
    21.     } finally {
    22.         if (gotSecondLock) lock2.unlock();
    23.         if (gotFirstLock) lock1.unlock();
    24.     }
    25. }

问题3：如何检测和解决线程泄漏？

问题描述： 线程泄漏会导致系统资源不断被消耗，最终可能导致OutOfMemoryError。

解决方案：

  1. 使用线程池： 而不是直接创建线程
  2. 始终关闭线程池： 使用try-finally确保关闭
  3. 设置合理的线程池大小： 避免创建过多线程
  4. 监控线程数量： 定期检查应用程序的线程数量
  1. // 正确使用线程池的方式
  2. ExecutorService executor = null;
  3. try {
  4.     executor = Executors.newFixedThreadPool(10);
  6.     // 提交任务到线程池
  7.     for (int i = 0; i < 100; i++) {
  8.         executor.submit(new Task(i));
  9.     }
  11. } finally {
  12.     // 确保线程池被关闭
  13.     if (executor != null) {
  14.         executor.shutdown();
  15.         try {
  16.             // 等待所有任务完成，但最多等待60秒
  17.             if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
  18.                 // 如果等待超时，强制关闭
  19.                 executor.shutdownNow();
  20.             }
  21.         } catch (InterruptedException e) {
  22.             // 如果当前线程被中断，重新中断，并强制关闭线程池
  23.             Thread.currentThread().interrupt();
  24.             executor.shutdownNow();
  25.         }
  26.     }
  27. }

小结

在本章中，我们深入学习了Java线程的生命周期和状态转换：

  1. 线程的六大状态： 我们详细了解了Java线程的六种状态（NEW、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING和TERMINATED）及其特点。

  2. 状态转换机制： 我们通过代码示例和状态转换图，理解了线程如何在不同状态之间转换，以及哪些方法会触发这些转换。

  3. 线程卡死问题： 我们学习了几种常见的线程卡死情况（死锁、活锁、饥饿和线程泄漏）及其解决方案。

  4. 实战应用： 我们创建了一个线程状态监控工具，可以实时监控线程状态的变化，这对调试多线程应用非常有用。

理解线程的生命周期对于开发高效、可靠的多线程应用至关重要。通过掌握线程状态转换的规律和可能出现的问题，你可以更好地设计和调试多线程程序。

在下一章中，我们将学习线程的基本操作，包括启动、休眠、中断、连接等，进一步增强你的多线程编程技能。

本章节源代码地址为 https://github.com/qianmoQ/tutorial/tree/main/java-multithreading-tutorial/src/main/java/org/devlive/tutorial/multithreading/chapter02