Java线程池性能优化：避免细粒度任务带来的陷阱

private static final int NB_THREADS = 8;
private static final ThreadPoolExecutor executor = (ThreadPoolExecutor) 
    Executors.newFixedThreadPool(NB_THREADS);

private Set<ReversiState> getChildrenParallel() {
    HashSet<Future<Void>> threadResults = new HashSet<>();
    HashSet<ReversiState> childrenSet = new HashSet<>(); // 非线程安全

    for(int row=0; row<BOARD_SIZE; row++){
        for(int col=0; col<BOARD_SIZE; col++){
            final Integer rowFinal = row;
            final Integer colFinal = col;

            // 提交一个细粒度任务，其中addChildrenForPosition是耗时操作
            Future<Void> future = executor.submit(
                () -> addChildrenForPosition(childrenSet, rowFinal, colFinal), 
                null);
            threadResults.add(future);
        }
    }

    // 等待所有任务完成
    for(Future<Void> future : threadResults){
        try{
            future.get();
        } catch(Exception e){
            e.printStackTrace();
        }
    }
    return childrenSet;
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.*;

// 假设 ReversiState 是一个已定义的类
class ReversiState {
    // ... 棋盘状态相关属性和方法
}

// 假设 BOARD_SIZE 是一个已定义的常量
class GameSolver {
    private static final int BOARD_SIZE = 8; // 示例值
    private static final int NB_THREADS = 8;
    private static final ThreadPoolExecutor executor = (ThreadPoolExecutor) 
        Executors.newFixedThreadPool(NB_THREADS);

    // 模拟耗时操作，生成子节点并添加到集合
    private void addChildrenForPosition(Set<ReversiState> targetSet, int row, int col) {
        // 模拟生成子节点逻辑
        // targetSet.add(new ReversiState(...)); 
        try {
            Thread.sleep(1); // 模拟少量计算
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        targetSet.add(new ReversiState()); // 示例：添加一个空状态
    }

    private Set<ReversiState> getChildrenParallelOptimized() throws InterruptedException, ExecutionException {
        List<Callable<Set<ReversiState>>> tasks = new ArrayList<>();
        // 为每个位置创建一个独立的任务，让其返回自己的结果
        for(int row=0; row<BOARD_SIZE; row++){
            for(int col=0; col<BOARD_SIZE; col++){
                final Integer rowFinal = row;
                final Integer colFinal = col;
                tasks.add(() -> {
                    HashSet<ReversiState> localChildrenSet = new HashSet<>();
                    // addChildrenForPosition现在只操作局部集合
                    addChildrenForPosition(localChildrenSet, rowFinal, colFinal); 
                    return localChildrenSet;
                });
            }
        }

        // 批量提交任务并获取结果
        List<Future<Set<ReversiState>>> futures = executor.invokeAll(tasks);

        HashSet<ReversiState> childrenSet = new HashSet<>();
        for (Future<Set<ReversiState>> future : futures) {
            childrenSet.addAll(future.get()); // 合并局部结果
        }
        return childrenSet;
    }

    // 确保线程池在程序结束时关闭
    public void shutdownExecutor() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}