62、Java 线程管理、异常处理与局部变量深度解析

Java 线程管理、异常处理与局部变量深度解析

1. 线程管理与线程组

在多线程编程中，将线程组织成相关的组是一种有效的管理和安全策略。线程组可以嵌套，形成一个层次结构，其顶层为系统线程组。

线程组的主要作用包括：
- 管理线程 ：可以将组内的线程作为一个单元进行管理，例如一次性中断组内的所有线程，或者设置组内线程的最大优先级。
- 定义安全域 ：线程组可以定义一个安全域，组内的线程通常可以修改组内的其他线程，但应用程序可以定义安全策略来限制线程对组外线程的修改。不同线程组的线程可以被授予不同的操作权限，如 I/O 操作。

安全敏感的方法在执行前会检查是否安装了安全管理器。如果安全策略禁止该操作，方法会抛出 SecurityException 。默认情况下，应用程序启动时没有安装安全管理器，但在某些环境中，如浏览器中的小程序，通常会安装安全管理器。

每个线程都属于一个线程组，由 ThreadGroup 对象表示。可以在创建线程时指定其所属的线程组，默认情况下，新线程会与创建它的线程属于同一个线程组，除非安全管理器另有规定。

以下是一个指定线程组的 Thread 构造函数示例：

public Thread(ThreadGroup group, String name)

该构造函数在指定的线程组中创建一个具有给定名称的新线程。如果当前线程没有权限将线程放入指定的线程组，这些构造函数可能会抛出 SecurityException 。

线程创建后，与之关联的 ThreadGroup 对象不能更改。可以通过 getThreadGroup 方法获取线程的组，通过 checkAccess 方法检查是否有权限修改线程。

线程组可以是守护组，与守护线程的概念无关。当守护线程组为空时，它会自动被销毁。设置线程组为守护组不会影响组内线程或子组是否为守护线程，仅影响组为空时的行为。

线程组还可以设置其包含线程的优先级上限。调用 setMaxPriority 方法设置最大优先级后，任何尝试将线程优先级设置为高于组最大优先级的操作都会被自动调整为该最大值，现有线程不受此调用影响。

以下是一个设置线程优先级并调整组最大优先级的示例方法：

static synchronized void
    maxThread(Thread thr, int priority)
{
    ThreadGroup grp = thr.getThreadGroup();
    thr.setPriority(priority);
    grp.setMaxPriority(thr.getPriority() - 1);
}

该方法将线程的优先级设置为所需值，然后将组的最大允许优先级设置为低于线程的优先级。

ThreadGroup 类支持以下构造函数和方法：
| 方法 | 描述 |
| — | — |
| public ThreadGroup(String name) | 创建一个新的线程组，其父组为当前线程的线程组 |
| public ThreadGroup(ThreadGroup parent, String name) | 在指定的父线程组中创建一个具有指定名称的新线程组 |
| public final String getName() | 返回线程组的名称 |
| public final ThreadGroup getParent() | 返回父线程组，如果没有则返回 null |
| public final void setDaemon(boolean daemon) | 设置线程组的守护状态 |
| public final boolean isDaemon() | 返回线程组的守护状态 |
| public final void setMaxPriority(int maxPri) | 设置线程组的最大优先级 |
| public final int getMaxPriority() | 获取线程组的当前最大优先级 |
| public final boolean parentOf(ThreadGroup g) | 检查该线程组是否是指定线程组的父组或就是该线程组 |
| public final void checkAccess() | 检查当前线程是否有权限修改该线程组 |
| public final void destroy() | 销毁线程组，组内必须没有线程 |

可以使用以下两组方法来检查线程组的内容：
- 获取线程 ：
- public int activeCount() ：返回组内活动线程的估计数量，包括所有子组中的线程。
- public int enumerate(Thread[] threadsInGroup, boolean recurse) ：将组内的活动线程引用填充到数组中，并返回存储的线程数量。 recurse 参数决定是否递归包含子组中的线程。
- public int enumerate(Thread[] threadsInGroup) ：等效于 enumerate(threadsInGroup, true) 。
- 获取线程组 ：
- public int activeGroupCount() ：返回组内活动线程组的数量。
- public int enumerate(ThreadGroup[] groupsInGroup, boolean recurse) ：将组内的线程组引用填充到数组中，并返回存储的线程组数量。
- public int enumerate(ThreadGroup[] groupsInGroup) ：等效于 enumerate(groupsInGroup, true) 。

还可以使用线程组来管理组内的线程，调用 interrupt 方法会中断组内的所有线程，包括子组中的线程。 Thread 类还提供了两个静态方法来操作当前线程的组：

public static int activeCount()
public static int enumerate(Thread[] threadsInGroup)

ThreadGroup 类还支持一个方法，当线程因未捕获的异常而终止时会调用该方法：

public void uncaughtException(Thread thr, Throwable exc)

2. 线程与异常

异常总是在特定的线程中发生，例如尝试进行零除操作或显式抛出异常。这种异常是同步异常，始终在发生的线程内。如果父线程想知道子线程终止的原因，子线程需要将该信息存储在父线程可以访问的地方。将线程启动调用放在 try-catch 块中只能捕获 start 方法抛出的异常，而不能捕获新线程抛出的异常。

当异常抛出时，它会导致语句突然完成，并在每个方法调用突然完成时向上传播调用栈。如果在 run 方法突然完成时异常仍未被捕获，则该异常为未捕获异常。此时，发生异常的线程已终止，异常也不再存在。

为了跟踪未捕获异常的发生，每个线程可以关联一个 UncaughtExceptionHandler 实例。 UncaughtExceptionHandler 是 Thread 类的嵌套接口，声明了一个方法：

public void uncaughtException(Thread thr, Throwable exc)

当线程因抛出异常而终止时，会调用该方法。

可以使用 setUncaughtExceptionHandler 方法设置线程的未捕获异常处理程序。当线程因未捕获异常即将终止时，运行时会调用 getUncaughtExceptionHandler 方法查询处理程序，并调用返回的处理程序的 uncaughtException 方法。

getUncaughtExceptionHandler 方法会返回线程通过 setUncaughtExceptionHandler 方法显式设置的处理程序，如果没有显式设置，则返回线程的 ThreadGroup 对象。线程终止且没有组时， getUncaughtExceptionHandler 可能返回 null 。

ThreadGroup 的 uncaughtException 方法的默认实现会调用父组的 uncaughtException 方法（如果有父组）。如果线程组没有父组，则会查询系统的默认未捕获异常处理程序。如果存在默认处理程序，则调用其 uncaughtException 方法；否则，调用异常的 printStackTrace 方法显示异常信息（如果异常不是 ThreadDeath 实例）。

应用程序可以在三个级别控制未捕获异常的处理：
- 系统级别 ：使用 Thread 类的静态方法 setDefaultUncaughtExceptionHandler 设置默认处理程序，该操作会进行安全检查。
- 组级别 ：通过扩展 ThreadGroup 类并覆盖 uncaughtException 方法。
- 线程级别 ：调用线程的 setUncaughtExceptionHandler 方法。

例如，在图形环境中，可以定义自己的 UncaughtExceptionHandler 来在窗口中显示堆栈跟踪信息，而不是将其打印到 System.err 。

3. 避免使用 Thread.stop 方法

在 Java 中， Thread.stop 方法已被弃用。该方法会在调用它的线程中抛出一个异步的 ThreadDeath 异常。这个异常可以被捕获，如果未被捕获，它会一直传播直到线程终止。异常可以在线程执行的几乎任何点发生，但在尝试获取锁时不会发生。

stop 方法的初衷是强制线程以受控方式终止，通过抛出一个不太可能被捕获的异常，允许使用 finally 子句进行正常的清理操作。但该方法存在两个严重问题：
- 无法强制线程终止 ：线程可以捕获并忽略抛出的异常，因此对恶意代码无效。
- 可能导致对象损坏 ：如果在线程处于临界区时调用 stop 方法，同步锁会在异常传播时释放，但对象可能会因临界区的部分完成而处于损坏状态。

因此，建议使用 interrupt 方法来协作取消线程的操作。

4. 堆栈跟踪

任何存活的线程都可以查询其当前的执行堆栈跟踪。 getStackTrace 方法返回一个 StackTraceElement 对象数组，其中第 0 个元素表示线程当前正在执行的方法。如果线程未存活，则返回一个长度为 0 的数组。

可以使用 Thread 类的静态方法 getAllStackTraces 访问系统中所有线程的堆栈跟踪信息，该方法返回一个映射，将每个线程映射到其对应的 StackTraceElement 数组。

堆栈跟踪信息通常用于调试和监控目的，例如当应用程序“挂起”时，监控线程可以显示所有线程的堆栈跟踪，帮助开发者了解每个线程正在执行的操作。但如果应用程序因代码错误而挂起，监控线程可能无法执行。虚拟机不要求为任何给定线程生成非零长度的堆栈跟踪，并且可以省略堆栈跟踪信息中的某些方法。

5. 线程局部变量

ThreadLocal 类允许创建一个逻辑上的单一变量，在每个独立的线程中具有独立的值。每个 ThreadLocal 对象都有一个 set 方法用于设置当前线程中变量的值，一个 get 方法用于返回当前线程中变量的值。

以下是一个使用 ThreadLocal 的示例：

public class Operations {
    private static ThreadLocal<User> users = 
        new ThreadLocal<User>() {
            /** Initially start as the "unknown user". */
            protected User initialValue() {
                return User.UNKNOWN_USER;
            }
        };
    private static User currentUser() {
        return users.get();
    }
    public static void setUser(User newUser) {
        users.set(newUser);
    }
    public void setValue(int newValue) {
        User user = currentUser();
        if (!canChange(user))
            throw new SecurityException();
        // ... modify the value ...
    }
    // ...
}

在这个示例中， users 是一个 ThreadLocal 变量，每个线程的初始值为 User.UNKNOWN_USER 。可以通过 setUser 方法为给定线程设置用户， currentUser 方法会返回该线程的当前用户。

可以使用 remove 方法清除 ThreadLocal 中的值，再次调用 get 方法时，会使用 initialValue 方法确定返回值。

当线程死亡时，该线程中 ThreadLocal 变量设置的值将无法访问，如果没有其他引用，这些值将被垃圾回收。

创建新线程时，新线程中 ThreadLocal 变量的值将是 initialValue 方法返回的值。如果希望新线程继承创建它的线程的值，可以使用 InheritableThreadLocal 类，它是 ThreadLocal 的子类，有一个 childValue 方法用于获取子线程的初始值。

使用 ThreadLocal 对象存在一定风险，特别是在使用线程池的情况下。线程池会重用线程， ThreadLocal 对象可能会保留上一次使用该线程的代码设置的状态，而不是新线程执行开始时预期的未初始化状态。因此，只有在完全理解线程模型的情况下才应使用 ThreadLocal 对象。

综上所述，Java 中的线程管理、异常处理和局部变量是多线程编程中非常重要的概念，合理使用这些特性可以提高程序的性能和安全性。在实际开发中，需要根据具体需求选择合适的方法和工具，避免使用已弃用的方法，确保代码的健壮性和可维护性。

Java 线程管理、异常处理与局部变量深度解析

6. 线程管理与线程组的操作细节

线程组在 Java 多线程编程中扮演着重要的角色，下面详细介绍一些线程组操作的具体流程和注意事项。

6.1 创建线程组

创建线程组有两种方式，分别使用不同的构造函数：
- 使用 public ThreadGroup(String name) ：这种方式创建的线程组，其父组为当前线程的线程组。示例代码如下：

ThreadGroup currentGroup = Thread.currentThread().getThreadGroup();
ThreadGroup newGroup = new ThreadGroup("NewGroup");
System.out.println("NewGroup's parent: " + newGroup.getParent().getName());

• 使用 public ThreadGroup(ThreadGroup parent, String name) ：可以指定父线程组来创建新的线程组。示例代码如下：

ThreadGroup parentGroup = new ThreadGroup("ParentGroup");
ThreadGroup childGroup = new ThreadGroup(parentGroup, "ChildGroup");
System.out.println("ChildGroup's parent: " + childGroup.getParent().getName());

6.2 设置线程组属性

线程组的属性设置主要包括守护状态和最大优先级。
- 设置守护状态 ：使用 public final void setDaemon(boolean daemon) 方法。示例代码如下：

ThreadGroup group = new ThreadGroup("DaemonGroup");
group.setDaemon(true);
System.out.println("Is DaemonGroup a daemon group? " + group.isDaemon());

• 设置最大优先级 ：使用 public final void setMaxPriority(int maxPri) 方法。示例代码如下：

ThreadGroup priorityGroup = new ThreadGroup("PriorityGroup");
priorityGroup.setMaxPriority(Thread.NORM_PRIORITY - 1);
System.out.println("PriorityGroup's max priority: " + priorityGroup.getMaxPriority());

6.3 枚举线程组内容

可以使用枚举方法来获取线程组内的线程和子线程组。以下是一个示例，展示如何递归枚举线程组内的所有线程：

ThreadGroup rootGroup = Thread.currentThread().getThreadGroup();
while (rootGroup.getParent() != null) {
    rootGroup = rootGroup.getParent();
}
Thread[] allThreads = new Thread[rootGroup.activeCount()];
int threadCount = rootGroup.enumerate(allThreads, true);
for (int i = 0; i < threadCount; i++) {
    System.out.println("Thread: " + allThreads[i].getName());
}

7. 线程异常处理的实际应用

在实际开发中，合理处理线程异常可以提高程序的健壮性。下面通过一个示例展示如何在不同级别处理未捕获异常。

7.1 系统级别处理

在系统级别设置默认的未捕获异常处理程序，示例代码如下：

Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("System-level handler caught exception in thread " + t.getName() + ": " + e.getMessage());
    }
});
Thread thread = new Thread(() -> {
    throw new RuntimeException("System-level exception");
});
thread.start();

7.2 组级别处理

通过扩展 ThreadGroup 类并覆盖 uncaughtException 方法来实现组级别处理，示例代码如下：

class CustomThreadGroup extends ThreadGroup {
    public CustomThreadGroup(String name) {
        super(name);
    }
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("Group-level handler caught exception in thread " + t.getName() + ": " + e.getMessage());
    }
}
CustomThreadGroup customGroup = new CustomThreadGroup("CustomGroup");
Thread groupThread = new Thread(customGroup, () -> {
    throw new RuntimeException("Group-level exception");
});
groupThread.start();

7.3 线程级别处理

在单个线程上设置未捕获异常处理程序，示例代码如下：

Thread singleThread = new Thread(() -> {
    throw new RuntimeException("Thread-level exception");
});
singleThread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("Thread-level handler caught exception in thread " + t.getName() + ": " + e.getMessage());
    }
});
singleThread.start();

8. 线程局部变量的使用场景与风险规避

ThreadLocal 变量在某些场景下非常有用，但也存在一定风险，下面分别介绍其使用场景和风险规避方法。

8.1 使用场景

ThreadLocal 常用于为每个线程维护独立的状态。例如，在 Web 应用中，为每个请求线程维护用户会话信息。示例代码如下：

public class WebSession {
    private static ThreadLocal<String> sessionId = new ThreadLocal<String>() {
        @Override
        protected String initialValue() {
            return null;
        }
    };
    public static void setSessionId(String id) {
        sessionId.set(id);
    }
    public static String getSessionId() {
        return sessionId.get();
    }
    public static void clearSessionId() {
        sessionId.remove();
    }
}

8.2 风险规避

在使用线程池时，为了避免 ThreadLocal 变量保留上一次使用该线程的状态，可以在任务执行前后进行清理操作。示例代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolWithThreadLocal {
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        for (int i = 0; i < 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                try {
                    threadLocal.set(taskId);
                    System.out.println("Task " + taskId + " has threadLocal value: " + threadLocal.get());
                } finally {
                    threadLocal.remove();
                }
            });
        }
        executor.shutdown();
    }
}

9. 线程管理与异常处理的流程图

graph TD;
    A[开始] --> B[创建线程组];
    B --> C{是否需要设置属性};
    C -- 是 --> D[设置守护状态或最大优先级];
    C -- 否 --> E[创建线程放入线程组];
    D --> E;
    E --> F{线程执行是否抛出异常};
    F -- 是 --> G{异常处理级别};
    G -- 系统级别 --> H[系统默认处理程序处理];
    G -- 组级别 --> I[线程组处理程序处理];
    G -- 线程级别 --> J[线程特定处理程序处理];
    F -- 否 --> K[线程正常执行结束];
    H --> K;
    I --> K;
    J --> K;
    K --> L[线程组操作（枚举等）];
    L --> M[结束];

10. 总结

Java 中的线程管理、异常处理和局部变量是多线程编程中不可或缺的部分。线程组提供了一种有效的方式来组织和管理线程，同时可以定义安全域。异常处理机制确保了程序在遇到异常时能够有合适的处理方式，避免程序崩溃。 ThreadLocal 变量则为每个线程提供了独立的变量副本，方便维护线程特定的状态。

在实际开发中，需要根据具体的业务需求和场景，合理运用这些特性。避免使用已弃用的方法，如 Thread.stop ，同时注意 ThreadLocal 在线程池环境中的使用风险。通过合理的设计和实现，可以提高程序的性能、安全性和可维护性。

通过本文的介绍，希望读者能够对 Java 多线程编程中的这些重要概念有更深入的理解，并在实际项目中灵活运用。