面试题：Java并发编程中异常处理与线程生命周期的关联

Question

在Java复杂的并发场景下，线程抛出异常后，其生命周期会受到怎样的影响？如何设计健壮的异常处理机制，确保线程即使在异常情况下，也能按照预期释放资源并维持系统的稳定性？请结合具体案例详细阐述。

Answer 1

线程抛出异常后生命周期的影响

在Java并发场景下，当线程抛出未捕获的异常时，该线程会终止。线程一旦终止，就进入了 TERMINATED 状态，它将不再执行后续代码，也无法再次启动。

健壮异常处理机制设计

1. 使用 try - catch 块 在每个线程的执行代码中，使用 try - catch 块捕获异常，避免异常直接导致线程终止。例如：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        try {
            // 可能抛出异常的代码
            int result = 10 / 0; 
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        }
    }
}

2. 自定义 UncaughtExceptionHandler 通过设置 Thread.UncaughtExceptionHandler，可以在异常未被捕获时执行自定义的处理逻辑。例如：

class CustomUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println("线程 " + t.getName() + " 抛出未捕获异常: " + e.getMessage());
        // 可以在这里进行资源释放等操作
    }
}

public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            int result = 10 / 0; 
        });
        thread.setUncaughtExceptionHandler(new CustomUncaughtExceptionHandler());
        thread.start();
    }
}

3. 确保资源正确释放 使用 try - finally 块或 try - with - resources（针对实现了 AutoCloseable 接口的资源）确保在异常发生时资源被正确释放。例如：

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

public class ResourceReleaseExample {
    public static void main(String[] args) {
        try (InputStream inputStream = new FileInputStream("nonexistentfile.txt")) {
            // 读取文件的代码
        } catch (IOException e) {
            System.out.println("读取文件时发生异常: " + e.getMessage());
        }
    }
}

4. 使用线程池 线程池可以管理线程的生命周期，当线程抛出异常时，线程池可以根据配置决定是否重新创建线程。例如：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.submit(() -> {
            int result = 10 / 0; 
        });
        executorService.shutdown();
    }
}

通过以上方法，可以在Java复杂并发场景下设计健壮的异常处理机制，确保线程在异常情况下能正确释放资源并维持系统稳定性。