本文深入探讨了java多线程编程中一个常见的陷阱：当使用`executorservice`时，如果任务类不当地在`run()`方法内部创建新的`thread`实例，会导致输出重复或行为异常。文章通过分析问题代码，揭示了将任务定义为`runnable`接口实现而非直接继承`thread`，并正确使用`thread.currentthread().getname()`获取当前执行线程名称的重要性。通过遵循这些最佳实践，可以有效避免多线程环境下的逻辑混乱和资源浪费，确保程序行为符合预期。
Java多线程编程中的重复输出问题解析
在Java多线程应用开发中，尤其是在使用线程池（ExecutorService）管理任务时，开发者可能会遇到线程行为异常或输出重复的问题。一个典型的场景是，尽管我们期望每个任务只执行一次并输出相应信息，但实际运行结果却显示某些任务（尤其是最后一个）的信息被重复打印多次。这通常是由于对Java线程模型和ExecutorService工作原理的误解所导致的。
问题现象与初步分析
考虑以下代码示例，它尝试使用线程池来模拟一系列随机休眠的任务：
sampleThread.java (原始问题代码)
import java.util.Random;
public class sampleThread extends Thread {
sampleThread thread; // 声明一个实例变量
Random rand = new Random();
public void run() {
thread = new sampleThread(); // 在run方法内创建新的sampleThread实例
int randSleep = rand.nextInt(1000);
System.out.println(thread.getName() + " is sleeping for " + randSleep + " milliseconds");
try {
Thread.sleep(randSleep);
System.out.println(thread.getName() + " is NOW AWAKE");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}driver.java (原始问题代码)
立即学习“Java免费学习笔记（深入）”；
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class driver {
public static void main(String[] args) throws ExecutionException, InterruptedException {
List<Future<?>> futArray = new ArrayList<>();
ExecutorService es = Executors.newFixedThreadPool(6); // 创建一个固定大小为6的线程池
sampleThread temp = new sampleThread(); // 创建一个sampleThread实例
for (int i = 0; i < 120; i++) {
Future<?> future = es.submit(temp); // 将同一个temp实例提交120次
futArray.add(future);
}
// ... 后续可能还有关闭线程池等操作
}
}当运行上述代码时，我们可能会观察到如下输出：
Thread-117 is sleeping for 547 milliseconds Thread-117 is NOW AWAKE Thread-118 is sleeping for 442 milliseconds Thread-118 is NOW AWAKE Thread-119 is sleeping for 182 milliseconds Thread-119 is NOW AWAKE Thread-120 is sleeping for 487 milliseconds Thread-120 is NOW AWAKE Thread-120 is NOW AWAKE Thread-120 is NOW AWAKE Thread-120 is NOW AWAKE Thread-120 is NOW AWAKE Thread-120 is NOW AWAKE
可以看到，最后一条线程的“NOW AWAKE”信息被重复打印了多次，这与预期不符。
根本原因分析
这个问题的核心在于对Thread类的不当使用以及在run()方法内部创建新线程实例的错误操作。
-
不当的Thread继承与实例化：
- sampleThread类继承了Thread。当一个类继承Thread时，它的实例本身就是一个线程对象。
- 在driver.java中，sampleThread temp = new sampleThread(); 创建了一个sampleThread对象。
- 然后，这个temp对象被同一个实例提交到ExecutorService 120次。ExecutorService会从其线程池中分配一个工作线程来执行temp对象的run()方法。
- 关键错误： 在sampleThread的run()方法内部，有这样一行代码：thread = new sampleThread();。这意味着，每当线程池中的一个工作线程执行temp.run()方法时，它都会在内部创建一个全新的sampleThread实例（并赋值给temp对象的thread成员变量）。然后，System.out.println(thread.getName() + ...) 打印的是这个内部新创建线程的名称，而不是当前正在执行run()方法的线程池工作线程的名称。
-
线程名称的混淆：
- Thread.getName()方法返回的是当前Thread实例的名称。由于在run()方法内部不断创建新的sampleThread实例，并使用这些新实例的getName()方法，导致打印的线程名称与实际执行任务的线程池工作线程不一致。
- 由于ExecutorService的线程池大小是固定的（例如6个），这6个工作线程会轮流执行120个任务。每个任务在执行时都会创建一个新的sampleThread对象。当最后一个任务被执行时，它创建的sampleThread实例可能恰好拥有一个递增的线程ID（如Thread-120）。由于driver.java中提交的是同一个temp实例，其thread成员变量在每次执行run()时都会被新的sampleThread实例覆盖。这导致在某些情况下，当temp实例的run()方法被多个线程池工作线程并发执行时，对temp.thread的写入和读取可能会发生竞态条件，从而导致同一个Thread-X的输出被重复打印，因为它可能被多个工作线程在几乎相同的时间点更新并读取。
正确的解决方案
解决此问题的关键在于遵循Java并发编程的最佳实践：
实现Runnable接口而非继承Thread类： 当使用ExecutorService时，任务通常应该实现Runnable接口。ExecutorService负责管理底层的线程，我们只需要提供任务逻辑。继承Thread类通常只在需要重写Thread的特定行为时才考虑，但对于简单的任务执行，Runnable更简洁且更符合职责分离原则。
获取当前执行线程的名称： 要获取当前正在执行run()方法的线程的名称，应使用静态方法Thread.currentThread().getName()。这会返回执行当前代码块的线程的实际名称，而不是某个特定Thread实例的名称。
以下是修改后的sampleThread类：
sampleThread.java (修正版)
import java.util.Random;
// 1. 实现Runnable接口
public class sampleThread implements Runnable {
Random rand = new Random();
public void run() {
// 2. 移除在run方法内创建新sampleThread实例的代码
// 3. 使用Thread.currentThread().getName() 获取当前执行线程的名称
String threadName = Thread.currentThread().getName();
int randSleep = rand.nextInt(1000);
System.out.println(threadName + " is sleeping for " + randSleep + " milliseconds");
try {
Thread.sleep(randSleep);
System.out.println(threadName + " is NOW AWAKE");
} catch (InterruptedException e) {
// 最佳实践：在捕获InterruptedException后，重新设置中断标志
Thread.currentThread().interrupt();
System.err.println(threadName + " was interrupted while sleeping.");
// 可以选择抛出RuntimeException，或者更优雅地处理中断
// throw new RuntimeException(e);
}
}
}driver.java (修正版)
driver.java中的修改主要在于提交任务时，每次循环都创建一个新的sampleThread实例，因为Runnable实例代表一个独立的任务。
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class driver {
public static void main(String[] args) throws ExecutionException, InterruptedException {
List<Future<?>> futArray = new ArrayList<>();
ExecutorService es = Executors.newFixedThreadPool(6); // 创建一个固定大小为6的线程池
for (int i = 0; i < 120; i++) {
// 每次循环创建一个新的Runnable实例
sampleThread task = new sampleThread();
Future<?> future = es.submit(task); // 提交不同的task实例
futArray.add(future);
}
// 确保所有任务完成，并关闭线程池
for (Future<?> future : futArray) {
future.get(); // 阻塞直到任务完成
}
es.shutdown(); // 启动有序关闭
if (!es.awaitTermination(60, java.util.concurrent.TimeUnit.SECONDS)) {
es.shutdownNow(); // 如果超时，则强制关闭
}
System.out.println("All tasks completed and ExecutorService shut down.");
}
}现在，运行修正后的代码，输出将是这样的：
pool-1-thread-1 is sleeping for 526 milliseconds pool-1-thread-6 is sleeping for 497 milliseconds pool-1-thread-4 is sleeping for 565 milliseconds pool-1-thread-5 is sleeping for 978 milliseconds pool-1-thread-2 is sleeping for 917 milliseconds pool-1-thread-3 is sleeping for 641 milliseconds pool-1-thread-6 is NOW AWAKE pool-1-thread-6 is sleeping for 847 milliseconds pool-1-thread-1 is NOW AWAKE pool-1-thread-1 is sleeping for 125 milliseconds // ... (其他线程的交错输出) pool-1-thread-3 is NOW AWAKE pool-1-thread-5 is NOW AWAKE pool-1-thread-6 is NOW AWAKE pool-1-thread-4 is NOW AWAKE pool-1-thread-1 is NOW AWAKE pool-1-thread-2 is NOW AWAKE pool-1-thread-3 is NOW AWAKE All tasks completed and ExecutorService shut down.
可以看到，输出现在清晰地显示了线程池中的6个工作线程（如pool-1-thread-1到pool-1-thread-6）轮流执行任务，并且每个任务的“NOW AWAKE”信息只打印一次，符合预期。
注意事项与最佳实践
-
Runnable vs. Thread：
- 实现Runnable： 这是在Java中定义任务的首选方式。它将任务的逻辑（run()方法）与执行任务的线程分离开来。这使得代码更灵活，因为同一个Runnable实例可以被多个线程执行（尽管通常每个任务实例只提交一次），也更容易与ExecutorService集成。
- 继承Thread： 当你需要创建自定义的线程子类，并且需要重写Thread类的某些行为时才使用。但对于大多数并发任务，Runnable是更优的选择。
-
ExecutorService的正确使用：
- ExecutorService用于管理线程的生命周期，包括创建、调度和销毁。
- 向ExecutorService提交任务时，通常是提交Runnable或Callable的实例。
- 重要： 如果你的任务是状态敏感的，或者每个任务都需要独立的数据，那么每次提交任务时都应该创建一个新的Runnable（或Callable）实例。避免重复提交同一个Runnable实例，除非该Runnable是设计为无状态的，或者其内部状态在每次执行时都会被正确重置。在我们的示例中，每个sampleThread实例代表一个独立的休眠任务，因此每次循环都应该创建新的实例。
获取当前线程：Thread.currentThread()是一个静态方法，它返回当前正在执行代码的线程对象的引用。这是获取线程名称、检查中断状态等操作的正确方式。
异常处理： 在run()方法中捕获InterruptedException时，最佳实践是在捕获后重新设置线程的中断标志（Thread.currentThread().interrupt();），以便上层调用者能够感知到中断。
总结
理解Java多线程中的Thread和Runnable的区别，以及ExecutorService的工作机制，对于编写健壮、高效的并发程序至关重要。避免在run()方法内部错误地创建新的Thread实例，并始终使用Thread.currentThread().getName()来获取当前执行线程的名称，是避免多线程环境中常见陷阱的关键。通过遵循这些原则，开发者可以更好地控制线程行为，确保程序的正确性和可预测性。
