学习目标

  • 掌握线程启动(start)、休眠(sleep)和中断(interrupt)的正确使用方式
  • 理解线程Join操作的原理与适用场景
  • 学习如何设置和管理线程优先级
  • 了解守护线程(Daemon Thread)的特性及其应用

1. 线程启动(start)、休眠(sleep)、中断(interrupt)

1.1 线程启动(start)

在Java中，调用线程的start()方法才能真正启动一个线程。这个方法会创建新的执行线程，并使该线程开始执行run()方法中的代码。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 线程启动示例
  5.  */
  6. public class ThreadStartDemo {
  7.     public static void main(String[] args) {
  8.         // 创建线程
  9.         Thread thread = new Thread(() -> {
  10.             System.out.println("线程ID: " + Thread.currentThread().getId());
  11.             System.out.println("线程名称: " + Thread.currentThread().getName());
  12.             System.out.println("线程执行中...");
  13.         });
  15.         // 设置线程名称
  16.         thread.setName("MyCustomThread");
  18.         System.out.println("线程启动前的状态: " + thread.getState());
  20.         // 启动线程
  21.         thread.start();
  23.         // 等待一点时间，让线程有机会执行
  24.         try {
  25.             Thread.sleep(100);
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  30.         System.out.println("线程启动后的状态: " + thread.getState());
  31.     }
  32. }

⚠️ 重要提示： 不要多次调用同一个线程的start()方法。线程一旦启动并终止，就无法再次启动。如果尝试再次启动同一个线程，会抛出IllegalThreadStateException异常。

来看一个错误示例：

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 线程重复启动错误示例
  5.  */
  6. public class ThreadDoubleStartErrorDemo {
  7.     public static void main(String[] args) {
  8.         Thread thread = new Thread(() -> {
  9.             System.out.println("线程执行中...");
  10.         });
  12.         // 第一次启动线程（正确）
  13.         thread.start();
  15.         // 等待线程执行完毕
  16.         try {
  17.             thread.join();
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  22.         System.out.println("线程状态: " + thread.getState());
  24.         try {
  25.             // 尝试再次启动同一个线程（错误）
  26.             System.out.println("尝试再次启动同一个线程...");
  27.             thread.start();
  28.         } catch (IllegalThreadStateException e) {
  29.             System.out.println("捕获到异常: " + e.getMessage());
  30.             System.out.println("线程一旦终止，就不能再次启动！");
  31.         }
  32.     }
  33. }

📌 正确做法： 如果需要再次执行相同的任务，应该创建一个新的线程对象。

1.2 线程休眠(sleep)

Thread.sleep()方法可以使当前执行线程暂停执行指定的时间，让出CPU时间给其他线程，但不会释放当前线程所持有的锁。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.time.LocalTime;
  4. import java.time.format.DateTimeFormatter;
  6. /**
  7.  * 线程休眠示例
  8.  */
  9. public class ThreadSleepDemo {
  10.     public static void main(String[] args) {
  11.         // 时间格式化器
  12.         DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");
  14.         // 创建并启动3个线程
  15.         for (int i = 1; i <= 3; i++) {
  16.             final int threadId = i;
  17.             new Thread(() -> {
  18.                 for (int j = 1; j <= 5; j++) {
  19.                     // 打印当前时间和线程信息
  20.                     String time = LocalTime.now().format(formatter);
  21.                     System.out.println(time + " - 线程" + threadId + " 执行第" + j + "次");
  23.                     try {
  24.                         // 线程休眠随机时间（0.5-2秒）
  25.                         long sleepTime = 500 + (long)(Math.random() * 1500);
  26.                         Thread.sleep(sleepTime);
  27.                     } catch (InterruptedException e) {
  28.                         System.out.println("线程" + threadId + " 被中断");
  29.                         return; // 提前结束线程
  30.                     }
  31.                 }
  32.                 System.out.println("线程" + threadId + " 执行完毕");
  33.             }, "线程" + i).start();
  34.         }
  35.     }
  36. }

sleep()方法有两个重载版本：

  1. public static void sleep(long millis) throws InterruptedException
  2. public static void sleep(long millis, int nanos) throws InterruptedException

📌 注意： sleep()方法会抛出InterruptedException，这是一个检查型异常，必须处理。通常有两种处理方式：向上抛出或捕获处理。

sleep()方法与锁的关系示例：

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 演示sleep方法不会释放锁
  5.  */
  6. public class ThreadSleepWithLockDemo {
  8.     private static final Object lock = new Object();
  10.     public static void main(String[] args) {
  11.         // 创建第一个线程，获取锁后休眠
  12.         Thread thread1 = new Thread(() -> {
  13.             synchronized (lock) {
  14.                 System.out.println("线程1获取到锁");
  15.                 System.out.println("线程1开始休眠3秒...");
  16.                 try {
  17.                     Thread.sleep(3000);
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.                 System.out.println("线程1休眠结束，释放锁");
  22.             }
  23.         });
  25.         // 创建第二个线程，尝试获取锁
  26.         Thread thread2 = new Thread(() -> {
  27.             System.out.println("线程2尝试获取锁...");
  28.             synchronized (lock) {
  29.                 System.out.println("线程2获取到锁");
  30.             }
  31.             System.out.println("线程2释放锁");
  32.         });
  34.         // 启动线程
  35.         thread1.start();
  37.         // 确保线程1先执行
  38.         try {
  39.             Thread.sleep(500);
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  44.         thread2.start();
  45.     }
  46. }

在上面的例子中，当线程1调用sleep()方法时，它不会释放锁，因此线程2必须等待线程1的睡眠时间结束并释放锁后才能获取锁继续执行。

1.3 线程中断(interrupt)

Java提供了一种协作式的线程中断机制，它不会强制终止线程，而是通过设置线程的中断标志，让线程自己决定如何响应中断请求。

通过以下方法可以实现线程中断：

  • public void interrupt()：中断线程，设置中断标志
  • public boolean isInterrupted()：检查线程是否被中断，不清除中断状态
  • public static boolean interrupted()：检查当前线程是否被中断，并清除中断状态
  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 线程中断示例
  5.  */
  6. public class ThreadInterruptDemo {
  7.     public static void main(String[] args) {
  8.         // 创建一个简单的可中断线程
  9.         Thread thread = new Thread(() -> {
  10.             int count = 0;
  12.             // 检查线程中断标志
  13.             while (!Thread.currentThread().isInterrupted()) {
  14.                 System.out.println("线程执行中... " + (++count));
  16.                 // 模拟工作
  17.                 try {
  18.                     Thread.sleep(1000);
  19.                 } catch (InterruptedException e) {
  20.                     // sleep方法被中断会清除中断状态，需要重新设置
  21.                     System.out.println("线程在sleep期间被中断");
  22.                     Thread.currentThread().interrupt(); // 重新设置中断状态
  23.                 }
  24.             }
  26.             System.out.println("线程检测到中断信号，正常退出");
  27.         });
  29.         // 启动线程
  30.         thread.start();
  32.         // 主线程休眠3秒后中断线程
  33.         try {
  34.             Thread.sleep(3000);
  35.         } catch (InterruptedException e) {
  36.             e.printStackTrace();
  37.         }
  39.         System.out.println("主线程发送中断信号");
  40.         thread.interrupt();
  41.     }
  42. }

⚠️ 重要说明： 当线程在sleep()、wait()或join()等阻塞方法中被中断时，这些方法会抛出InterruptedException并清除中断状态。因此，在捕获这些异常时，通常需要重新设置中断状态。

处理可中断阻塞操作的标准模式：

  1. try {
  2.     // 可中断的阻塞操作
  3.     Thread.sleep(timeoutMillis);
  4.     // 正常处理
  5. } catch (InterruptedException e) {
  6.     // 可以记录日志
  8.     // 重新设置中断状态
  9.     Thread.currentThread().interrupt();
  11.     // 可以选择提前返回或终止循环
  12.     return;
  13. }

2. 线程Join操作及其应用场景

join()方法允许一个线程等待另一个线程完成。当在线程A中调用线程B的join()方法时，线程A将被阻塞，直到线程B完成执行。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 线程Join示例
  5.  */
  6. public class ThreadJoinDemo {
  7.     public static void main(String[] args) {
  8.         // 创建3个执行特定任务的线程
  9.         Thread thread1 = new Thread(() -> {
  10.             System.out.println("线程1开始执行...");
  11.             try {
  12.                 // 模拟耗时操作
  13.                 Thread.sleep(2000);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.             System.out.println("线程1执行完毕");
  18.         });
  20.         Thread thread2 = new Thread(() -> {
  21.             System.out.println("线程2开始执行...");
  22.             try {
  23.                 // 模拟耗时操作
  24.                 Thread.sleep(3000);
  25.             } catch (InterruptedException e) {
  26.                 e.printStackTrace();
  27.             }
  28.             System.out.println("线程2执行完毕");
  29.         });
  31.         Thread thread3 = new Thread(() -> {
  32.             System.out.println("线程3开始执行...");
  33.             try {
  34.                 // 模拟耗时操作
  35.                 Thread.sleep(1500);
  36.             } catch (InterruptedException e) {
  37.                 e.printStackTrace();
  38.             }
  39.             System.out.println("线程3执行完毕");
  40.         });
  42.         System.out.println("启动所有线程");
  44.         // 启动线程
  45.         thread1.start();
  46.         thread2.start();
  47.         thread3.start();
  49.         System.out.println("等待所有线程完成...");
  51.         try {
  52.             // 等待线程1完成
  53.             thread1.join();
  54.             System.out.println("线程1已完成");
  56.             // 等待线程2完成
  57.             thread2.join();
  58.             System.out.println("线程2已完成");
  60.             // 等待线程3完成
  61.             thread3.join();
  62.             System.out.println("线程3已完成");
  63.         } catch (InterruptedException e) {
  64.             System.out.println("主线程被中断");
  65.         }
  67.         System.out.println("所有线程已完成，继续执行主线程");
  68.     }
  69. }

join()方法有三个重载版本：

  1. public final void join() throws InterruptedException：等待线程终止
  2. public final void join(long millis) throws InterruptedException：等待线程终止，最多等待指定的毫秒数
  3. public final void join(long millis, int nanos) throws InterruptedException：等待线程终止，最多等待指定的毫秒数加纳秒数

2.1 Join操作的典型应用场景

  1. 等待所有工作线程完成

当主线程需要等待多个工作线程全部完成后再继续执行时，可以使用join()方法。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 等待多个工作线程完成示例
  8.  */
  9. public class MultiThreadJoinDemo {
  10.     public static void main(String[] args) {
  11.         List<Thread> threads = new ArrayList<>();
  13.         // 创建5个工作线程
  14.         for (int i = 1; i <= 5; i++) {
  15.             final int threadNum = i;
  16.             Thread thread = new Thread(() -> {
  17.                 System.out.println("工作线程" + threadNum + "开始执行...");
  19.                 // 模拟不同的工作负载
  20.                 try {
  21.                     Thread.sleep(1000 + threadNum * 500);
  22.                 } catch (InterruptedException e) {
  23.                     e.printStackTrace();
  24.                 }
  26.                 System.out.println("工作线程" + threadNum + "执行完毕");
  27.             });
  29.             threads.add(thread);
  30.             thread.start();
  31.         }
  33.         System.out.println("等待所有工作线程完成...");
  35.         // 等待所有线程完成
  36.         for (Thread thread : threads) {
  37.             try {
  38.                 thread.join();
  39.             } catch (InterruptedException e) {
  40.                 e.printStackTrace();
  41.             }
  42.         }
  44.         System.out.println("所有工作线程已完成，主线程继续执行");
  45.     }
  46. }
  1. 顺序执行多个任务

当多个任务必须按照特定顺序执行时，可以使用join()方法确保前一个任务完成后再开始下一个任务。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 顺序执行任务示例
  5.  */
  6. public class SequentialTasksDemo {
  7.     public static void main(String[] args) {
  8.         System.out.println("开始执行顺序任务");
  10.         // 步骤1：准备数据
  11.         Thread step1 = new Thread(() -> {
  12.             System.out.println("步骤1：准备数据...");
  13.             try {
  14.                 Thread.sleep(2000);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  18.             System.out.println("步骤1完成：数据准备好了");
  19.         });
  21.         // 步骤2：处理数据
  22.         Thread step2 = new Thread(() -> {
  23.             System.out.println("步骤2：处理数据...");
  24.             try {
  25.                 Thread.sleep(3000);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             System.out.println("步骤2完成：数据处理好了");
  30.         });
  32.         // 步骤3：保存结果
  33.         Thread step3 = new Thread(() -> {
  34.             System.out.println("步骤3：保存结果...");
  35.             try {
  36.                 Thread.sleep(1500);
  37.             } catch (InterruptedException e) {
  38.                 e.printStackTrace();
  39.             }
  40.             System.out.println("步骤3完成：结果已保存");
  41.         });
  43.         try {
  44.             // 启动第一个任务并等待完成
  45.             step1.start();
  46.             step1.join();
  48.             // 启动第二个任务并等待完成
  49.             step2.start();
  50.             step2.join();
  52.             // 启动第三个任务并等待完成
  53.             step3.start();
  54.             step3.join();
  55.         } catch (InterruptedException e) {
  56.             System.out.println("任务执行被中断");
  57.         }
  59.         System.out.println("所有步骤已完成");
  60.     }
  61. }
  1. 实现简单的任务分解与合并

在并行计算中，可以将大任务分解为多个小任务并行执行，然后使用join()等待所有小任务完成后合并结果。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.util.concurrent.atomic.AtomicLong;
  5. /**
  6.  * 并行计算示例：计算从1到n的总和
  7.  */
  8. public class ParallelSumDemo {
  9.     public static void main(String[] args) {
  10.         long n = 1_000_000_000L; // 计算1到10亿的和
  11.         int numThreads = 4; // 使用4个线程并行计算
  13.         // 存储最终结果
  14.         AtomicLong totalSum = new AtomicLong(0);
  16.         // 创建并启动工作线程
  17.         Thread[] threads = new Thread[numThreads];
  18.         for (int i = 0; i < numThreads; i++) {
  19.             final long start = i * (n / numThreads) + 1;
  20.             final long end = (i == numThreads - 1) ? n : (i + 1) * (n / numThreads);
  22.             threads[i] = new Thread(() -> {
  23.                 System.out.println("计算从 " + start + " 到 " + end + " 的和");
  24.                 long partialSum = 0;
  25.                 for (long j = start; j <= end; j++) {
  26.                     partialSum += j;
  27.                 }
  28.                 totalSum.addAndGet(partialSum);
  29.                 System.out.println("部分和 (" + start + "-" + end + "): " + partialSum);
  30.             });
  32.             threads[i].start();
  33.         }
  35.         // 等待所有线程完成
  36.         try {
  37.             for (Thread thread : threads) {
  38.                 thread.join();
  39.             }
  40.         } catch (InterruptedException e) {
  41.             e.printStackTrace();
  42.         }
  44.         // 输出最终结果
  45.         System.out.println("并行计算结果: " + totalSum.get());
  47.         // 验证结果
  48.         long expectedSum = n * (n + 1) / 2;
  49.         System.out.println("正确结果: " + expectedSum);
  50.         System.out.println("结果正确: " + (totalSum.get() == expectedSum));
  51.     }
  52. }

3. 线程优先级的设置与影响

Java线程的优先级为1~10的整数，默认优先级是5。线程优先级高的线程会获得更多的执行机会，但这只是一个提示，不能保证高优先级的线程一定先于低优先级的线程执行。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 线程优先级示例
  5.  */
  6. public class ThreadPriorityDemo {
  7.     public static void main(String[] args) {
  8.         // 创建3个不同优先级的线程
  9.         Thread lowPriorityThread = new Thread(() -> {
  10.             System.out.println("低优先级线程开始执行");
  11.             long count = 0;
  12.             for (long i = 0; i < 5_000_000_000L; i++) {
  13.                 count++;
  14.                 if (i % 1_000_000_000 == 0) {
  15.                     System.out.println("低优先级线程计数: " + i / 1_000_000_000);
  16.                 }
  17.             }
  18.             System.out.println("低优先级线程执行完毕，计数: " + count);
  19.         });
  21.         Thread normalPriorityThread = new Thread(() -> {
  22.             System.out.println("普通优先级线程开始执行");
  23.             long count = 0;
  24.             for (long i = 0; i < 5_000_000_000L; i++) {
  25.                 count++;
  26.                 if (i % 1_000_000_000 == 0) {
  27.                     System.out.println("普通优先级线程计数: " + i / 1_000_000_000);
  28.                 }
  29.             }
  30.             System.out.println("普通优先级线程执行完毕，计数: " + count);
  31.         });
  33.         Thread highPriorityThread = new Thread(() -> {
  34.             System.out.println("高优先级线程开始执行");
  35.             long count = 0;
  36.             for (long i = 0; i < 5_000_000_000L; i++) {
  37.                 count++;
  38.                 if (i % 1_000_000_000 == 0) {
  39.                     System.out.println("高优先级线程计数: " + i / 1_000_000_000);
  40.                 }
  41.             }
  42.             System.out.println("高优先级线程执行完毕，计数: " + count);
  43.         });
  45.         // 设置线程优先级
  46.         lowPriorityThread.setPriority(Thread.MIN_PRIORITY); // 1
  47.         normalPriorityThread.setPriority(Thread.NORM_PRIORITY); // 5
  48.         highPriorityThread.setPriority(Thread.MAX_PRIORITY); // 10
  50.         System.out.println("低优先级线程的优先级: " + lowPriorityThread.getPriority());
  51.         System.out.println("普通优先级线程的优先级: " + normalPriorityThread.getPriority());
  52.         System.out.println("高优先级线程的优先级: " + highPriorityThread.getPriority());
  54.         // 启动线程
  55.         System.out.println("启动所有线程");
  56.         lowPriorityThread.start();
  57.         normalPriorityThread.start();
  58.         highPriorityThread.start();
  59.     }
  60. }

⚠️ 重要说明： 线程优先级依赖于操作系统的支持，不同的操作系统对线程优先级的支持不同，有些操作系统甚至会忽略线程优先级。因此，不应该依赖线程优先级来确保程序的正确性。

线程优先级的最佳实践：

  1. 仅在需要微调性能时使用线程优先级
  2. 不要依赖线程优先级来确保程序的正确性
  3. 避免使用过高的优先级，可能会导致其他线程饥饿
  4. 避免频繁改变线程优先级

4. 守护线程(Daemon Thread)的应用

守护线程是为其他线程服务的线程，当所有非守护线程结束时，Java虚拟机会自动终止所有守护线程并退出。典型的守护线程有垃圾回收器、JIT编译器等。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. /**
  4.  * 守护线程示例
  5.  */
  6. public class DaemonThreadDemo {
  7.     public static void main(String[] args) {
  8.         // 创建一个守护线程
  9.         Thread daemonThread = new Thread(() -> {
  10.             int count = 0;
  11.             while (true) {
  12.                 try {
  13.                     Thread.sleep(1000);
  14.                     count++;
  15.                     System.out.println("守护线程工作中... 计数: " + count);
  16.                 } catch (InterruptedException e) {
  17.                     System.out.println("守护线程被中断");
  18.                     break;
  19.                 }
  20.             }
  21.         });
  23.         // 设置为守护线程
  24.         daemonThread.setDaemon(true);
  26.         // 创建一个普通线程
  27.         Thread userThread = new Thread(() -> {
  28.             for (int i = 1; i <= 5; i++) {
  29.                 System.out.println("用户线程工作中... " + i);
  30.                 try {
  31.                     Thread.sleep(2000);
  32.                 } catch (InterruptedException e) {
  33.                     e.printStackTrace();
  34.                 }
  35.             }
  36.             System.out.println("用户线程执行完毕");
  37.         });
  39.         System.out.println("守护线程状态: " + daemonThread.isDaemon());
  40.         System.out.println("用户线程状态: " + userThread.isDaemon());
  42.         // 启动线程
  43.         daemonThread.start();
  44.         userThread.start();
  46.         System.out.println("主线程等待用户线程完成...");
  47.         try {
  48.             userThread.join();
  49.         } catch (InterruptedException e) {
  50.             e.printStackTrace();
  51.         }
  53.         System.out.println("主线程结束，JVM即将退出");
  54.         // 不需要等待守护线程结束，JVM会自动终止所有守护线程
  55.     }
  56. }

⚠️ 注意： 必须在调用start()方法之前设置线程为守护线程，否则会抛出IllegalThreadStateException异常。

4.1 守护线程的应用场景

  1. 后台清理任务

守护线程适合执行不需要用户交互的后台任务，如清理过期缓存、定期日志滚动等。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.time.LocalDateTime;
  4. import java.time.format.DateTimeFormatter;
  5. import java.util.concurrent.ConcurrentHashMap;
  6. import java.util.concurrent.TimeUnit;
  8. /**
  9.  * 使用守护线程实现缓存清理
  10.  */
  11. public class DaemonThreadCacheCleanerDemo {
  13.     // 简单的内存缓存
  14.     private static class SimpleCache {
  15.         // 缓存数据，键是缓存项的名称，值是包含数据和过期时间的CacheItem
  16.         private final ConcurrentHashMap<String, CacheItem> cache = new ConcurrentHashMap<>();
  18.         // 缓存项，包含实际数据和过期时间
  19.         private static class CacheItem {
  20.             private final Object data;
  21.             private final long expireTime; // 过期时间戳（毫秒）
  23.             public CacheItem(Object data, long ttlMillis) {
  24.                 this.data = data;
  25.                 this.expireTime = System.currentTimeMillis() + ttlMillis;
  26.             }
  28.             public boolean isExpired() {
  29.                 return System.currentTimeMillis() > expireTime;
  30.             }
  32.             @Override
  33.             public String toString() {
  34.                 return data.toString();
  35.             }
  36.         }
  38.         // 添加缓存项
  39.         public void put(String key, Object value, long ttlMillis) {
  40.             cache.put(key, new CacheItem(value, ttlMillis));
  41.             System.out.println("添加缓存项: " + key + " = " + value + ", TTL: " + ttlMillis + "ms");
  42.         }
  44.         // 获取缓存项
  45.         public Object get(String key) {
  46.             CacheItem item = cache.get(key);
  47.             if (item == null) {
  48.                 return null; // 缓存中没有该项
  49.             }
  51.             if (item.isExpired()) {
  52.                 cache.remove(key); // 惰性删除过期项
  53.                 return null;
  54.             }
  56.             return item.data;
  57.         }
  59.         // 获取缓存大小
  60.         public int size() {
  61.             return cache.size();
  62.         }
  64.         // 启动清理守护线程
  65.         public void startCleanerThread() {
  66.             Thread cleanerThread = new Thread(() -> {
  67.                 System.out.println("缓存清理线程启动");
  68.                 while (true) {
  69.                     try {
  70.                         TimeUnit.SECONDS.sleep(1); // 每秒检查一次
  72.                         // 记录当前时间
  73.                         String now = LocalDateTime.now().format(
  74.                                 DateTimeFormatter.ofPattern("HH:mm:ss"));
  76.                         System.out.println("\n" + now + " - 开始清理过期缓存项...");
  77.                         int beforeSize = cache.size();
  79.                         // 清理过期的缓存项
  80.                         cache.forEach((key, item) -> {
  81.                             if (item.isExpired()) {
  82.                                 System.out.println("移除过期缓存项: " + key);
  83.                                 cache.remove(key);
  84.                             }
  85.                         });
  87.                         int afterSize = cache.size();
  88.                         System.out.println("清理完成: 移除了 " + (beforeSize - afterSize) + " 个过期项，当前缓存大小: " + afterSize);
  89.                     } catch (InterruptedException e) {
  90.                         System.out.println("缓存清理线程被中断");
  91.                         break;
  92.                     }
  93.                 }
  94.             });
  96.             // 设置为守护线程
  97.             cleanerThread.setDaemon(true);
  98.             cleanerThread.start();
  99.         }
  100.     }
  102.     public static void main(String[] args) throws InterruptedException {
  103.         // 创建缓存并启动清理线程
  104.         SimpleCache cache = new SimpleCache();
  105.         cache.startCleanerThread();
  107.         // 添加一些缓存项，设置不同的过期时间
  108.         cache.put("item1", "Value 1", 3000); // 3秒后过期
  109.         cache.put("item2", "Value 2", 7000); // 7秒后过期
  110.         cache.put("item3", "Value 3", 5000); // 5秒后过期
  111.         cache.put("item4", "Value 4", 10000); // 10秒后过期
  113.         // 主线程每隔一段时间检查缓存中的项
  114.         for (int i = 1; i <= 12; i++) {
  115.             System.out.println("\n===== " + i + "秒后 =====");
  116.             System.out.println("item1: " + cache.get("item1"));
  117.             System.out.println("item2: " + cache.get("item2"));
  118.             System.out.println("item3: " + cache.get("item3"));
  119.             System.out.println("item4: " + cache.get("item4"));
  121.             // 每检查一次，等待1秒
  122.             TimeUnit.SECONDS.sleep(1);
  123.         }
  125.         System.out.println("\n主线程执行完毕，程序即将退出");
  126.         // 当主线程结束后，守护线程也会自动结束
  127.     }
  128. }
  1. 监控和维护服务

守护线程可以用于监控应用程序的健康状态、收集性能指标等。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.lang.management.ManagementFactory;
  4. import java.lang.management.MemoryMXBean;
  5. import java.time.LocalDateTime;
  6. import java.time.format.DateTimeFormatter;
  7. import java.util.concurrent.TimeUnit;
  9. /**
  10.  * 使用守护线程实现系统监控
  11.  */
  12. public class DaemonThreadMonitoringDemo {
  13.     public static void main(String[] args) {
  14.         // 启动系统监控守护线程
  15.         startMonitoringThread();
  17.         // 模拟主应用程序
  18.         System.out.println("主应用程序开始运行...");
  20.         // 执行一些内存密集型操作，让监控线程有些变化可以报告
  21.         for (int i = 0; i < 5; i++) {
  22.             System.out.println("\n===== 执行任务 " + (i + 1) + " =====");
  24.             // 分配一些内存
  25.             byte[][] arrays = new byte[i + 1][1024 * 1024]; // 分配 (i+1) MB的内存
  27.             // 模拟一些处理
  28.             try {
  29.                 TimeUnit.SECONDS.sleep(3);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  34.             // 释放部分内存
  35.             if (i % 2 == 0) {
  36.                 arrays[0] = null; // 释放第一个数组
  37.             }
  38.         }
  40.         System.out.println("\n主应用程序执行完毕，即将退出");
  41.     }
  43.     private static void startMonitoringThread() {
  44.         Thread monitorThread = new Thread(() -> {
  45.             // 获取内存管理 MXBean
  46.             MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
  47.             DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
  49.             System.out.println("系统监控线程启动");
  51.             try {
  52.                 while (true) {
  53.                     // 获取当前时间
  54.                     String time = LocalDateTime.now().format(formatter);
  56.                     // 收集内存使用情况
  57.                     long heapUsed = memoryBean.getHeapMemoryUsage().getUsed();
  58.                     long heapMax = memoryBean.getHeapMemoryUsage().getMax();
  59.                     long nonHeapUsed = memoryBean.getNonHeapMemoryUsage().getUsed();
  61.                     // 计算内存使用百分比
  62.                     double heapUsagePercent = (double) heapUsed / heapMax * 100;
  64.                     // 输出监控信息
  65.                     System.out.println("\n[" + time + "] 系统监控:");
  66.                     System.out.printf("堆内存使用: %.2f MB / %.2f MB (%.1f%%)\n", 
  67.                             heapUsed / (1024.0 * 1024.0), 
  68.                             heapMax / (1024.0 * 1024.0),
  69.                             heapUsagePercent);
  70.                     System.out.printf("非堆内存使用: %.2f MB\n", 
  71.                             nonHeapUsed / (1024.0 * 1024.0));
  73.                     // 检查是否内存使用过高
  74.                     if (heapUsagePercent > 70) {
  75.                         System.out.println("警告: 内存使用率过高!");
  76.                     }
  78.                     // 每2秒收集一次信息
  79.                     TimeUnit.SECONDS.sleep(2);
  80.                 }
  81.             } catch (InterruptedException e) {
  82.                 System.out.println("监控线程被中断");
  83.             }
  84.         });
  86.         // 设置为守护线程
  87.         monitorThread.setDaemon(true);
  88.         monitorThread.setName("系统监控线程");
  89.         monitorThread.start();
  90.     }
  91. }
  1. 自动保存线程

守护线程可以用于定期保存用户工作，确保即使程序意外退出，用户也不会丢失太多数据。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.io.File;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  6. import java.time.LocalDateTime;
  7. import java.time.format.DateTimeFormatter;
  8. import java.util.Scanner;
  9. import java.util.concurrent.TimeUnit;
  11. /**
  12.  * 使用守护线程实现自动保存功能
  13.  */
  14. public class DaemonThreadAutoSaveDemo {
  16.     // 模拟文档内容
  17.     private static StringBuilder documentContent = new StringBuilder();
  19.     // 文档是否被修改
  20.     private static volatile boolean documentModified = false;
  22.     // 记录上次保存时间
  23.     private static LocalDateTime lastSaveTime;
  25.     public static void main(String[] args) {
  26.         // 启动自动保存守护线程
  27.         startAutoSaveThread();
  29.         // 模拟文本编辑器
  30.         System.out.println("简易文本编辑器 (输入'exit'退出)");
  31.         System.out.println("----------------------");
  33.         Scanner scanner = new Scanner(System.in);
  35.         while (true) {
  36.             System.out.print("> ");
  37.             String line = scanner.nextLine();
  39.             if ("exit".equalsIgnoreCase(line)) {
  40.                 System.out.println("正在退出编辑器...");
  42.                 // 如果有未保存的内容，强制保存
  43.                 if (documentModified) {
  44.                     saveDocument();
  45.                 }
  47.                 break;
  48.             } else {
  49.                 // 添加用户输入到文档
  50.                 documentContent.append(line).append("\n");
  51.                 documentModified = true;
  52.                 System.out.println("文本已添加 (当前字符数: " + documentContent.length() + ")");
  53.             }
  54.         }
  56.         System.out.println("编辑器已关闭，程序退出");
  57.     }
  59.     private static void startAutoSaveThread() {
  60.         Thread autoSaveThread = new Thread(() -> {
  61.             System.out.println("自动保存线程已启动 (每10秒检查一次)");
  63.             while (true) {
  64.                 try {
  65.                     // 休眠10秒
  66.                     TimeUnit.SECONDS.sleep(10);
  68.                     // 检查文档是否被修改
  69.                     if (documentModified) {
  70.                         saveDocument();
  71.                     }
  72.                 } catch (InterruptedException e) {
  73.                     System.out.println("自动保存线程被中断");
  74.                     break;
  75.                 }
  76.             }
  77.         });
  79.         // 设置为守护线程
  80.         autoSaveThread.setDaemon(true);
  81.         autoSaveThread.setName("AutoSaveThread");
  82.         autoSaveThread.start();
  83.     }
  85.     private static void saveDocument() {
  86.         File file = new File("autosave_document.txt");
  88.         try (FileWriter writer = new FileWriter(file)) {
  89.             writer.write(documentContent.toString());
  91.             // 更新状态
  92.             documentModified = false;
  93.             lastSaveTime = LocalDateTime.now();
  95.             System.out.println("\n[自动保存] 文档已保存到: " + file.getAbsolutePath() + 
  96.                     " (" + lastSaveTime.format(DateTimeFormatter.ofPattern("HH:mm:ss")) + ")");
  97.         } catch (IOException e) {
  98.             System.out.println("\n[自动保存] 保存文档时出错: " + e.getMessage());
  99.         }
  100.     }
  101. }

5. 实战案例：文件搜索工具

让我们创建一个使用多线程的文件搜索工具，它可以在指定目录中搜索符合特定条件的文件，并显示搜索结果。这个案例将综合运用我们在本章学到的线程操作知识。

  1. package org.devlive.tutorial.multithreading.chapter03;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.nio.file.Files;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8. import java.util.concurrent.ConcurrentLinkedQueue;
  9. import java.util.concurrent.TimeUnit;
  10. import java.util.concurrent.atomic.AtomicInteger;
  12. /**
  13.  * 多线程文件搜索工具
  14.  */
  15. public class ConcurrentFileSearcher {
  17.     // 搜索结果
  18.     private final ConcurrentLinkedQueue<File> results = new ConcurrentLinkedQueue<>();
  20.     // 搜索线程数量
  21.     private final int threadCount;
  23.     // 搜索条件接口
  24.     public interface SearchCriteria {
  25.         boolean matches(File file);
  26.     }
  28.     // 构造函数
  29.     public ConcurrentFileSearcher(int threadCount) {
  30.         this.threadCount = threadCount;
  31.     }
  33.     /**
  34.      * 搜索文件
  35.      * @param startDir 起始目录
  36.      * @param criteria 搜索条件
  37.      * @return 匹配的文件列表
  38.      */
  39.     public List<File> search(File startDir, SearchCriteria criteria) {
  40.         if (!startDir.exists() || !startDir.isDirectory()) {
  41.             throw new IllegalArgumentException("起始目录不存在或不是一个目录: " + startDir);
  42.         }
  44.         // 清空上次搜索结果
  45.         results.clear();
  47.         // 计数器，用于跟踪处理的文件数和目录数
  48.         AtomicInteger processedFiles = new AtomicInteger(0);
  49.         AtomicInteger processedDirs = new AtomicInteger(0);
  51.         // 创建目录队列
  52.         ConcurrentLinkedQueue<File> directoryQueue = new ConcurrentLinkedQueue<>();
  53.         directoryQueue.add(startDir);
  55.         // 创建并启动工作线程
  56.         Thread[] searchThreads = new Thread[threadCount];
  57.         for (int i = 0; i < threadCount; i++) {
  58.             searchThreads[i] = new Thread(() -> {
  59.                 while (true) {
  60.                     // 从队列中获取下一个要处理的目录
  61.                     File currentDir = directoryQueue.poll();
  63.                     // 如果队列为空，检查是否所有线程都空闲
  64.                     if (currentDir == null) {
  65.                         // 等待一会儿，看看其他线程是否会添加新的目录
  66.                         try {
  67.                             TimeUnit.MILLISECONDS.sleep(100);
  68.                         } catch (InterruptedException e) {
  69.                             Thread.currentThread().interrupt();
  70.                             break;
  71.                         }
  73.                         // 再次检查队列
  74.                         if (directoryQueue.isEmpty()) {
  75.                             break; // 如果仍然为空，则结束线程
  76.                         } else {
  77.                             continue; // 如果有新目录，继续处理
  78.                         }
  79.                     }
  81.                     // 处理当前目录中的文件和子目录
  82.                     File[] items = currentDir.listFiles();
  83.                     if (items != null) {
  84.                         for (File item : items) {
  85.                             if (item.isDirectory()) {
  86.                                 // 将子目录添加到队列中
  87.                                 directoryQueue.add(item);
  88.                                 processedDirs.incrementAndGet();
  89.                             } else {
  90.                                 // 检查文件是否匹配搜索条件
  91.                                 if (criteria.matches(item)) {
  92.                                     results.add(item);
  93.                                 }
  94.                                 processedFiles.incrementAndGet();
  95.                             }
  96.                         }
  97.                     }
  98.                 }
  99.             });
  101.             // 设置线程名称并启动
  102.             searchThreads[i].setName("SearchThread-" + i);
  103.             searchThreads[i].start();
  104.         }
  106.         // 创建并启动一个守护线程来显示搜索进度
  107.         Thread progressThread = new Thread(() -> {
  108.             try {
  109.                 while (true) {
  110.                     int files = processedFiles.get();
  111.                     int dirs = processedDirs.get();
  112.                     int found = results.size();
  114.                     System.out.printf("\r处理中: %d 个文件, %d 个目录, 找到 %d 个匹配文件", 
  115.                             files, dirs, found);
  117.                     TimeUnit.SECONDS.sleep(1);
  118.                 }
  119.             } catch (InterruptedException e) {
  120.                 // 忽略中断
  121.             }
  122.         });
  123.         progressThread.setDaemon(true);
  124.         progressThread.start();
  126.         // 等待所有搜索线程完成
  127.         try {
  128.             for (Thread thread : searchThreads) {
  129.                 thread.join();
  130.             }
  131.         } catch (InterruptedException e) {
  132.             // 如果主线程被中断，中断所有搜索线程
  133.             for (Thread thread : searchThreads) {
  134.                 thread.interrupt();
  135.             }
  136.             Thread.currentThread().interrupt();
  137.         }
  139.         // 打印最终结果
  140.         System.out.println("\n搜索完成: 处理了 " + processedFiles.get() + " 个文件, " 
  141.                 + processedDirs.get() + " 个目录, 找到 " + results.size() + " 个匹配文件");
  143.         // 将结果转换为List并返回
  144.         return new ArrayList<>(results);
  145.     }
  147.     // 主程序示例
  148.     public static void main(String[] args) {
  149.         // 创建文件搜索器，使用4个线程
  150.         ConcurrentFileSearcher searcher = new ConcurrentFileSearcher(4);
  152.         // 定义搜索起始目录
  153.         File startDir = new File("C:/"); // Windows系统
  154.         // File startDir = new File("/"); // Linux/Mac系统
  156.         System.out.println("开始在 " + startDir + " 中搜索...");
  158.         // 定义搜索条件：查找大于10MB的Java源代码文件
  159.         SearchCriteria criteria = file -> {
  160.             // 检查文件扩展名
  161.             if (file.getName().endsWith(".java")) {
  162.                 try {
  163.                     // 检查文件大小（字节）
  164.                     return Files.size(file.toPath()) > 10 * 1024; // > 10KB
  165.                 } catch (IOException e) {
  166.                     return false;
  167.                 }
  168.             }
  169.             return false;
  170.         };
  172.         // 执行搜索
  173.         List<File> searchResults = searcher.search(startDir, criteria);
  175.         // 显示搜索结果
  176.         System.out.println("\n搜索结果:");
  177.         if (searchResults.isEmpty()) {
  178.             System.out.println("未找到匹配的文件");
  179.         } else {
  180.             for (int i = 0; i < searchResults.size(); i++) {
  181.                 File file = searchResults.get(i);
  182.                 try {
  183.                     long size = Files.size(file.toPath());
  184.                     String sizeStr = size < 1024 ? size + " B" :
  185.                                      size < 1024*1024 ? String.format("%.2f KB", size/1024.0) :
  186.                                      String.format("%.2f MB", size/(1024.0*1024.0));
  188.                     System.out.printf("%d. %s (大小: %s)\n", i + 1, file.getAbsolutePath(), sizeStr);
  189.                 } catch (IOException e) {
  190.                     System.out.printf("%d. %s (无法获取文件大小)\n", i + 1, file.getAbsolutePath());
  191.                 }
  192.             }
  193.         }
  194.     }
  195. }

在这个实战案例中，我们创建了一个多线程文件搜索工具，它可以高效地在指定目录中搜索符合特定条件的文件。主要特点：

  1. 使用多个线程并行搜索，提高搜索效率
  2. 使用线程安全的并发集合来共享数据
  3. 使用守护线程来显示搜索进度
  4. 使用原子变量来安全地计数
  5. 通过join()方法等待所有搜索线程完成
  6. 使用接口定义搜索条件，提高灵活性

常见问题与解决方案

问题1：主线程结束但程序不退出

问题描述： 有时主线程已经执行完所有代码，但整个Java程序却不退出。

原因： 这通常是因为程序中还有非守护线程在运行。只有当所有非守护线程都结束时，Java程序才会退出。

解决方案：

  1. 确保所有工作线程都能正常结束
  2. 对于不需要一直运行的后台任务，使用守护线程
  3. 使用线程池时，记得调用shutdown()方法

问题2：线程无法被中断

问题描述： 调用interrupt()方法后，线程没有响应中断请求，继续执行。

原因： 线程必须主动检查中断状态或处理InterruptedException才能响应中断请求。

解决方案：

  1. 在循环中定期检查中断状态：Thread.currentThread().isInterrupted()
  2. 正确处理InterruptedException，通常是重设中断状态并返回
  3. 避免屏蔽中断请求
  1. // 正确处理中断的方式
  2. public void run() {
  3.     try {
  4.         while (!Thread.currentThread().isInterrupted()) {
  5.             // 执行任务
  6.             doTask();
  8.             // 可中断的阻塞操作
  9.             Thread.sleep(100);
  10.         }
  11.     } catch (InterruptedException e) {
  12.         // 记录日志，清理资源
  14.         // 重新设置中断状态
  15.         Thread.currentThread().interrupt();
  16.     } finally {
  17.         // 清理资源
  18.         cleanup();
  19.     }
  20. }

问题3：线程优先级设置不生效

问题描述： 设置了线程的优先级，但没有观察到预期的效果。

原因： 线程优先级依赖于操作系统的支持，不同的操作系统对线程优先级的支持程度不同。

解决方案：

  1. 不要依赖线程优先级来保证程序的正确性
  2. 使用其他机制（如线程池的任务队列）来控制任务的执行顺序
  3. 在需要严格控制执行顺序的场景，使用明确的同步机制

小结

在本章中，我们学习了线程的基本操作及其应用：

  1. 线程的基本操作： 我们学习了如何启动线程、让线程休眠以及正确地中断线程。这些是多线程编程的基础操作，掌握这些操作可以帮助我们更好地控制线程的行为。

  2. 线程Join操作： 我们了解了join()方法的作用及其适用场景，如等待工作线程完成、顺序执行任务和实现简单的任务分解与合并。

  3. 线程优先级： 我们学习了如何设置线程优先级，以及线程优先级的影响。同时，我们也认识到线程优先级的局限性，不应该依赖线程优先级来确保程序的正确性。

  4. 守护线程： 我们了解了守护线程的概念和特性，以及其在后台任务、监控和自动保存等场景的应用。

  5. 实战应用： 通过文件搜索工具的实战案例，我们将所学知识应用到实际问题中，创建了一个高效的多线程文件搜索工具。

通过本章的学习，你应该能够熟练地操作线程，包括启动、休眠、中断和连接线程，以及合理地设置线程优先级和使用守护线程。这些知识为后续深入学习线程同步和并发控制奠定了基础。

在下一章中，我们将开始探讨线程安全问题，学习如何识别和解决多线程程序中的并发问题。

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