循环启停线程是否合理？频繁启停ExecutorService的用法疑问

首先直接点出你当前代码的核心问题：你把ExecutorService定义为实例变量，但每次调用execute方法后都调用executorService.shutdown()——这会导致第一次调用方法后，线程池就被关闭了，后续再调用execute方法提交任务时，会直接抛出RejectedExecutionException，因为关闭后的线程池不再接受新任务。

接下来聊聊你担心的「频繁创建关闭线程池」的问题：

• 线程池的设计初衷就是复用线程，避免频繁创建和销毁线程带来的性能开销（线程创建涉及操作系统内核态的操作，成本很高）。如果每次处理一组任务就创建新线程池、用完就关闭，完全违背了线程池的设计目的，会显著降低程序性能，尤其是在调用频率高的场景下。

正确的改进方案 #

1. 复用线程池（推荐） #

把ExecutorService作为类的成员变量初始化一次，在类的整个生命周期内复用，只在类不再被使用时（比如应用 shutdown 或者类销毁时）关闭线程池：

// 作为实例变量，只初始化一次
private final ExecutorService executorService = Executors.newFixedThreadPool(2);

public ExtractedInfo execute(String sku, String inputText) {
    ExtractedInfo info = new ExtractedInfo();
    Callable<List<Subgraph>> retrieveTask = () -> this.retrieveAllAttributesFromGraph(sku);
    Callable<String> parseTask = () -> this.executeParser(sku, inputText);

    Future<List<Subgraph>> retrieveFuture = executorService.submit(retrieveTask);
    Future<String> parseFuture = executorService.submit(parseTask);

    try {
        // 建议添加超时时间，避免任务无限阻塞
        String inputLine = parseFuture.get(10, TimeUnit.SECONDS);
        List<Subgraph> allAttributes = retrieveFuture.get(10, TimeUnit.SECONDS);
        
        info.setInputLine(inputLine);
        info.setAttributes(allAttributes);
    } catch (ExecutionException ee) {
        // 这里建议替换printStackTrace，改为日志记录或业务异常处理
        log.error("Task execution failed", ee);
        // 可以考虑设置默认值或者抛出自定义异常
        info.setError("Task execution failed: " + ee.getMessage());
    } catch (InterruptedException ie) {
        log.error("Task was interrupted", ie);
        Thread.currentThread().interrupt(); // 恢复中断状态
        info.setError("Task was interrupted");
    } catch (TimeoutException te) {
        log.error("Task execution timed out", te);
        info.setError("Task execution timed out");
    }

    // 不要在这里shutdown！
    return info;
}

// 在类的销毁逻辑中关闭线程池（比如Spring的@PreDestroy，或者自定义销毁方法）
public void destroy() {
    executorService.shutdown();
    try {
        // 等待现有任务完成，最多等30秒
        if (!executorService.awaitTermination(30, TimeUnit.SECONDS)) {
            executorService.shutdownNow(); // 强制关闭未完成的任务
        }
    } catch (InterruptedException ie) {
        executorService.shutdownNow();
        Thread.currentThread().interrupt();
    }
}

2. 若必须每次处理后关闭（不推荐，仅适用于极低频率调用场景） #

如果你的业务场景确实要求每次处理一组任务后就关闭线程池，那应该每次创建新的ExecutorService，而不是复用实例变量：

public ExtractedInfo execute(String sku, String inputText) {
    ExtractedInfo info = new ExtractedInfo();
    // 每次调用时创建新的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(2);
    try {
        Callable<List<Subgraph>> retrieveTask = () -> this.retrieveAllAttributesFromGraph(sku);
        Callable<String> parseTask = () -> this.executeParser(sku, inputText);

        Future<List<Subgraph>> retrieveFuture = executorService.submit(retrieveTask);
        Future<String> parseFuture = executorService.submit(parseTask);

        executorService.shutdown(); // 提交完任务后关闭，不再接受新任务
        try {
            String inputLine = parseFuture.get(10, TimeUnit.SECONDS);
            List<Subgraph> allAttributes = retrieveFuture.get(10, TimeUnit.SECONDS);
            
            info.setInputLine(inputLine);
            info.setAttributes(allAttributes);
        } catch (ExecutionException | InterruptedException | TimeoutException e) {
            log.error("Task processing failed", e);
            // 错误处理逻辑
        }
    } finally {
        // 确保线程池最终被关闭
        if (!executorService.isShutdown()) {
            executorService.shutdownNow();
        }
    }

    return info;
}

注意：Java 9+ 中ExecutorService实现了AutoCloseable，可以用try-with-resources简化关闭逻辑；Java 8及以前需要手动在finally块中处理。

额外的优化建议 #

• 避免使用Executors.newFixedThreadPool()这种默认的线程池创建方式，建议手动使用ThreadPoolExecutor构造函数，明确指定线程池的核心参数（如核心线程数、最大线程数、队列大小、拒绝策略等），这样能更好地控制线程池的行为，避免资源耗尽。
• 处理Future.get()时一定要添加超时时间，防止某个任务因为外部依赖故障等原因无限阻塞，导致方法一直挂起。

内容的提问来源于stack exchange，提问作者user697911