调用parallelStream()后如何清理残留的ForkJoinPool工作线程？

调用parallelStream()后会残留ForkJoinPool工作线程，尽管这些线程通常无危害，但从技术层面可以通过以下方式处理：

示例代码 #

import java.util.*;

public class Main
{
    public void test() {
        List<String> names = Arrays.asList("Alex", "Bob", "Cathy", "David");
        
        printThreads();
        names.parallelStream().forEach(name -> {
            if (name.length() < 5) {
                System.out.println(String.format("Short name = %s", name));
            }
        });
        printThreads();
    }
    
    public void printThreads() {
        Thread thread = Thread.currentThread();
        Thread[] listThreads = new Thread[thread.getThreadGroup().activeCount()];
        thread.getThreadGroup().enumerate(listThreads);
        System.out.println(String.format("List of threads: %s", Arrays.asList(listThreads)));
    }
    
    public static void main(String[] args) {
        new Main().test();
    }
}

输出结果 #

List of threads: [Thread[main,5,main]]
Short name = Bob
Short name = Alex
List of threads: [Thread[main,5,main], Thread[ForkJoinPool.commonPool-worker-3,5,main]]

技术层面的清除方法 #

1. 自定义ForkJoinPool执行并行流（推荐） #

默认的ForkJoinPool.commonPool是静态复用的，线程驻留是为了提升后续任务执行效率。如果要彻底清除线程，可以使用自定义池执行并行流任务，任务结束后关闭池：

import java.util.*;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ExecutionException;

public class Main
{
    public void test() {
        List<String> names = Arrays.asList("Alex", "Bob", "Cathy", "David");
        
        printThreads();
        // 自定义ForkJoinPool，指定并行度
        ForkJoinPool customPool = new ForkJoinPool(4);
        try {
            customPool.submit(() -> 
                names.parallelStream().forEach(name -> {
                    if (name.length() < 5) {
                        System.out.printf("Short name = %s%n", name);
                    }
                })
            ).get(); // 等待任务完成
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            customPool.shutdown(); // 关闭池，销毁所有空闲工作线程
        }
        printThreads();
    }
    
    public void printThreads() {
        Thread thread = Thread.currentThread();
        Thread[] listThreads = new Thread[thread.getThreadGroup().activeCount()];
        thread.getThreadGroup().enumerate(listThreads);
        System.out.println(String.format("List of threads: %s", Arrays.asList(listThreads)));
    }
    
    public static void main(String[] args) {
        new Main().test();
    }
}

这种方式完全可控，自定义池关闭后，工作线程会被销毁，不会残留。

2. 调整公共池线程存活时间（JDK 11+） #

从JDK 11开始，可以通过系统属性配置ForkJoinPool.commonPool的空闲线程存活时间，超时后线程会自动销毁。启动JVM时添加以下参数：

-Djdk.commonPool.keepAliveTime=60s

注意这是全局配置，会影响所有依赖公共池的代码。

3. 强制销毁公共池线程（不推荐） #

通过反射获取公共池的内部线程并中断，但这种方法依赖JDK私有API，版本兼容性差，可能导致后续并行流任务崩溃，仅用于研究场景，绝对禁止在生产环境使用。

总结 #

ForkJoinPool.commonPool的线程复用是JDK的优化设计，目的是避免频繁创建销毁线程带来的性能开销。除非有特殊需求，否则无需主动清除。如果必须清除，优先选择自定义ForkJoinPool的方式。

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