ThreadGroup可用于统一异常处理，通过重写uncaughtException方法集中捕获组内线程的未捕获异常，适用于需监控和响应线程崩溃的场景。
ThreadGroup在Java中提供了一种层级结构来组织和管理一组相关的线程。它最核心的作用，在我看来，就是提供了一个统一的父级，让你可以对一组线程进行批量的操作，比如中断它们，或者为它们设置一个默认的未捕获异常处理器。这对于一些需要整体控制线程生命周期的场景，或者想集中处理异常的系统，确实能提供一些便利。
要在Java中使用
ThreadGroup管理线程，基本步骤并不复杂，但理解其背后的设计哲学更重要。
首先，你需要创建一个
ThreadGroup实例。这就像是给你的线程们建了一个“部门”：
ThreadGroup myGroup = new ThreadGroup("MyApplicationThreads");
System.out.println("线程组 '" + myGroup.getName() + "' 已创建，父组是: " + myGroup.getParent().getName());接下来，当你创建
Thread对象时，就可以将它们分配到这个
ThreadGroup中。
立即学习“Java免费学习笔记（深入）”；
Runnable task = () -> {
try {
System.out.println(Thread.currentThread().getName() + " 正在执行...");
Thread.sleep(2000); // 模拟工作
// 模拟一个异常
if (Thread.currentThread().getName().contains("Worker-2")) {
throw new RuntimeException("Oops! 线程 " + Thread.currentThread().getName() + " 出错了。");
}
System.out.println(Thread.currentThread().getName() + " 完成。");
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " 被中断了。");
Thread.currentThread().interrupt(); // 重新设置中断标志
}
};
Thread t1 = new Thread(myGroup, task, "Worker-1");
Thread t2 = new Thread(myGroup, task, "Worker-2");
Thread t3 = new Thread(myGroup, task, "Worker-3");
t1.start();
t2.start();
t3.start();通过
ThreadGroup，你可以对组内的所有线程进行一些批量操作。比如，中断所有线程：
// 假设我们想在某个时刻中断所有线程 // myGroup.interrupt(); // 慎用，这会中断组内所有线程
你也可以枚举组内活跃的线程：
// 等待一小段时间，确保线程有时间启动
try {
Thread.sleep(500);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
Thread[] activeThreads = new Thread[myGroup.activeCount() * 2]; // 留足空间，因为activeCount只是一个估计值
int numEnumerated = myGroup.enumerate(activeThreads, false); // false表示不递归子组
System.out.println("\n当前线程组 '" + myGroup.getName() + "' 中的活跃线程:");
for (int i = 0; i < numEnumerated; i++) {
System.out.println("- " + activeThreads[i].getName() + " (状态: " + activeThreads[i].getState() + ")");
}值得一提的是，
ThreadGroup还支持层级结构，一个
ThreadGroup可以有子
ThreadGroup，这使得管理大型应用中的线程组织结构变得可能，尽管实际应用中，这种深度嵌套并不常见。
为什么在现代Java并发编程中，ThreadGroup
显得有些过时，但仍有其价值？
说实话，当我第一次接触
ThreadGroup时，觉得它挺酷的，能把线程“打包”管理。但在实际开发中，尤其是在Java 5引入
java.util.concurrent包之后，
ThreadGroup的很多功能都被更强大、更灵活的工具取代了。比如，
ExecutorService及其相关的
ThreadPoolExecutor，它们在线程的生命周期管理、任务调度、资源复用方面做得远比
ThreadGroup出色。
ThreadGroup最大的“短板”在于它的设计初衷更多是面向JVM内部的管理和安全控制，而不是作为应用程序开发者日常使用的线程管理工具。它没有提供像
ExecutorService那样的任务队列、拒绝策略等高级特性。比如，你不能直接给
ThreadGroup提交一个
Runnable或
Callable任务让它去执行，你仍然需要手动创建
Thread并指定
ThreadGroup。这使得它的使用场景变得相对小众。
然而，这不代表
ThreadGroup毫无用处。它仍然在某些特定场景下有其独特的价值。例如，统一的未捕获异常处理就是其中之一。每个
ThreadGroup都可以有一个默认的未捕获异常处理器（通过重写
uncaughtException方法），这对于监控和处理一组线程中发生的意料之外的错误非常有用。想象一下，你有一批执行后台任务的线程，你希望它们任何一个崩溃时都能被记录下来，甚至触发一些恢复机制，
ThreadGroup就能提供一个优雅的入口。此外，在一些遗留系统或者需要与JVM底层线程模型更紧密交互的场景中，
ThreadGroup也可能被用到。所以，与其说它“过时”，不如说它“特定化”了。
使用ThreadGroup
时常见的陷阱和更现代的替代方案是什么？
使用
ThreadGroup，你可能会遇到一些让人头疼的问题。一个常见的陷阱是，当你不清楚
ThreadGroup的层级关系时，可能会意外地中断了不该中断的线程，或者枚举到了不相关的线程。
interrupt()方法会递归地中断组内所有线程及其子组的线程，这在不经意间可能导致难以调试的问题。此外，
activeCount()和
enumerate()方法返回的数字和数组大小并不总是精确的，它们只是一个估计值，因为线程的状态是动态变化的。这可能导致你需要循环重试或者预留更大的数组空间，多少有点不便。
对于大多数现代Java应用来说，
ExecutorService是管理线程和任务的黄金标准。它提供了线程池的概念，可以有效地复用线程，避免了频繁创建和销毁线程的开销。你可以用它来提交
Runnable（无返回值任务）或
Callable（有返回值任务），并且能够方便地获取任务执行结果（通过
Future）。
比如，创建一个固定大小的线程池：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
// 替代方案示例
ExecutorService executor = Executors.newFixedThreadPool(3);
Runnable modernTask = () -> {
try {
System.out.println(Thread.currentThread().getName() + " (来自Executor) 正在执行...");
Thread.sleep(1500);
// 模拟一个异常
if (Thread.currentThread().getName().contains("pool-1-thread-2")) {
throw new IllegalStateException("Executor中的线程 " + Thread.currentThread().getName() + " 出错了！");
}
System.out.println(Thread.currentThread().getName() + " (来自Executor) 完成。");
} catch (InterruptedException e) {
System.out.println(Thread.currentThread().getName() + " (来自Executor) 被中断了。");
Thread.currentThread().interrupt();
}
};
executor.submit(modernTask);
executor.submit(modernTask);
executor.submit(modernTask);
// 关闭ExecutorService，等待任务完成
executor.shutdown();
try {
if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
executor.shutdownNow(); // 强制关闭
}
} catch (InterruptedException e) {
executor.shutdownNow();
Thread.currentThread().interrupt();
}ExecutorService还提供了更强大的异常处理机制，例如通过
Future.get()捕获
Callable任务的异常，或者通过自定义
RejectedExecutionHandler处理任务提交失败的情况。对于未捕获异常，你可以为线程池中的每个线程设置
Thread.UncaughtExceptionHandler，这比
ThreadGroup的机制更细粒度，也更灵活。
如何在实际项目中利用ThreadGroup
进行线程的统一异常处理？
尽管
ExecutorService在很多方面都更
