Java线程池性能反常：探究细粒度任务与并发优化策略

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;
            // 将每一个位置的子节点生成任务提交给线程池
            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.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

// 假设 ReversiState 和 addChildrenForPosition 已定义
// private static final int BOARD_SIZE = 8;
// private void addChildrenForPosition(Set<ReversiState> set, int row, int col) { ... }

public class GameSolverOptimizer {

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

    // 假设这是您的核心业务逻辑，为特定位置生成子节点
    private void addChildrenForPosition(Set<ReversiState> childrenSet, int row, int col) {
        // 模拟耗时操作，例如计算棋盘状态、复制对象等
        try {
            // Thread.sleep(1); // 模拟I/O或复杂计算
            childrenSet.add(new ReversiState(row, col)); // 假设 ReversiState 有合适的构造函数
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 假设 ReversiState 是一个简单的类，用于示例
    static class ReversiState {
        int row, col;
        public ReversiState(int row, int col) { this.row = row; this.col = col; }
        @Override
        public int hashCode() { return row * 31 + col; }
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            ReversiState other = (ReversiState) obj;
            return row == other.row && col == other.col;
        }
    }

    private Set<ReversiState> getChildrenParallelOptimized() throws Exception {
        List<Callable<Set<ReversiState>>> tasks = new ArrayList<>();
        int rowsPerThread = BOARD_SIZE / NB_THREADS;

        for (int i = 0; i < NB_THREADS; i++) {
            final int startRow = i * rowsPerThread;
            final int endRow = (i == NB_THREADS - 1) ? BOARD_SIZE : (i + 1) * rowsPerThread;

            // 每个 Callable 负责处理一个范围内的行，并在本地生成子节点集合
            tasks.add(() -> {
                HashSet<ReversiState> localChildrenSet = new HashSet<>();
                for (int row = startRow; row < endRow; row++) {
                    for (int col = 0; col < BOARD_SIZE; col++) {
                        // 核心工作在这里串行执行，减少线程间共享和同步
                        addChildrenForPosition(localChildrenSet, row, col);
                    }
                }
                return localChildrenSet;
            });
        }

        // 提交所有任务并等待结果
        List<Future<Set<ReversiState>>> futures = executor.invokeAll(tasks);

        // 合并所有线程的本地结果
        Set<ReversiState> childrenSet = Collections.synchronizedSet(new HashSet<>()); // 使用线程安全的Set进行最终合并
        for (Future<Set<ReversiState>> future : futures) {
            childrenSet.addAll(future.get()); // 获取每个线程的局部结果并添加到最终集合
        }
        return childrenSet;
    }

    public static void main(String[] args) throws Exception {
        GameSolverOptimizer solver = new GameSolverOptimizer();

        long startTime = System.nanoTime();
        Set<ReversiState> serialResult = solver.getChildrenSerial();
        long endTime = System.nanoTime();
        System.out.println("Serial version took: " + (endTime - startTime) / 1_000_000.0 + " ms. Size: " + serialResult.size());

        startTime = System.nanoTime();
        Set<ReversiState> parallelResult = solver.getChildrenParallelOptimized();
        endTime = System.nanoTime();
        System.out.println("Optimized parallel version took: " + (endTime - startTime) / 1_000_000.0 + " ms. Size: " + parallelResult.size());

        executor.shutdown();
    }

    // 原始串行版本，用于对比
    private Set<ReversiState> getChildrenSerial() {
        HashSet<ReversiState> childrenSet = new HashSet<>();
        for (int row = 0; row < BOARD_SIZE; row++) {
            for (int col = 0; col < BOARD_SIZE; col++) {
                addChildrenForPosition(childrenSet, row, col);
            }
        }
        return childrenSet;
    }
}