ForkJoinPool pool = new ForkJoinPool();
Integer result = pool.invoke(new SumTask(array, 0, array.length)); // 阻塞至任務(wù)完成

SumTask task = new SumTask(array, 0, array.length);
pool.execute(task);
// 后續(xù)通過 task.join() 獲取結(jié)果（會阻塞）

ForkJoinPool.commonPool().invoke(new SumTask(array, 0, array.length));

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

// 有返回值的任務(wù)：計算數(shù)組指定范圍的和
class SumTask extends RecursiveTask<Integer> {
    // 任務(wù)拆分閾值（小于該值則不拆分）
    private static final int THRESHOLD = 1000;
    private int[] array;
    private int start;
    private int end;

    public SumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        // 若任務(wù)足夠小，直接計算
        if (end - start <= THRESHOLD) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            // 拆分任務(wù)：分為左右兩個子任務(wù)
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(array, start, mid); // 左半部分任務(wù)
            SumTask rightTask = new SumTask(array, mid, end); // 右半部分任務(wù)

            //  執(zhí)行子任務(wù)（fork() 會將任務(wù)提交到線程池，可能并行執(zhí)行（非阻塞）
            leftTask.fork();
            // 直接執(zhí)行右任務(wù)（當(dāng)前線程可參與執(zhí)行，減少線程創(chuàng)建）
            int rightSum = rightTask.compute();
            // 等待左任務(wù)完成并獲取結(jié)果
            int leftSum = leftTask.join();

            // 合并結(jié)果
            return leftSum + rightSum;
        }
    }
}

public class ForkJoinPoolExample {
    public static void main(String[] args) {
        // 創(chuàng)建測試數(shù)組
        int[] array = new int[10_000_000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1; // 1~10,000,000
        }

        // 創(chuàng)建ForkJoinPool（默認(rèn)并行度為CPU核心數(shù)）
        try (ForkJoinPool pool = new ForkJoinPool()) {
            // 提交任務(wù)
            SumTask task = new SumTask(array, 0, array.length);
            Integer result = pool.invoke(task); // 阻塞等待結(jié)果

            System.out.println("數(shù)組總和：" + result); // 預(yù)期結(jié)果：50000005000000
        }
    }
}

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

// 無返回值的任務(wù)：打印數(shù)組指定范圍元素
class PrintTask extends RecursiveAction {
    private static final int THRESHOLD = 10;
    private int[] array;
    private int start;
    private int end;

    public PrintTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected void compute() {
        if (end - start <= THRESHOLD) {
            // 直接打印
            for (int i = start; i < end; i++) {
                System.out.print(array[i] + " ");
            }
        } else {
            // 拆分任務(wù)
            int mid = (start + end) / 2;
            PrintTask leftTask = new PrintTask(array, start, mid);
            PrintTask rightTask = new PrintTask(array, mid, end);

            leftTask.fork();
            rightTask.fork(); // 也可直接執(zhí)行rightTask.compute()

            // 等待子任務(wù)完成（無返回值，僅等待）
            leftTask.join();
            rightTask.join();
        }
    }
}

public class RecursiveActionExample {
    public static void main(String[] args) {
        int[] array = new int[30];
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1;
        }

        try (ForkJoinPool pool = new ForkJoinPool()) {
            pool.invoke(new PrintTask(array, 0, array.length));
        }
    }
}

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    @Resource
    private UserService userService;

    /**
     * 批量新增用戶數(shù)據(jù)
     */
    private void createBomPackage(List<User> users) {
        AtomicReference<Exception> exceptionRef = new AtomicReference<>();
        if (CollUtil.isNotEmpty(users)) {
            EXECUTOR.execute(() -> {
                ForkJoinPool forkJoinPool = new ForkJoinPool();
                try {
                    forkJoinPool.submit(new SumRecursiveTask(users, userService));
                } catch (Exception e) {
                    log.error("新增用戶數(shù)據(jù)失敗", e);
                    exceptionRef.set(e);
                } finally {
                    if (!forkJoinPool.isShutdown()) {
                        forkJoinPool.shutdown();
                    }
                }
            });
            if (exceptionRef.get() != null) {
                exceptionRef.get().printStackTrace();
                throw new BaseException("異步任務(wù)執(zhí)行新增用戶異常");
            }
        }
    }

    /**
     * 分批創(chuàng)建類
     */
    private static class SumRecursiveTask extends RecursiveAction {
        private static final int MAX_STRIDE = 200;      //可以處理任務(wù)
        @Resource
        private final UserService userService;
        private final List<User> users;
        
        public SumRecursiveTask(List<User> users, UserService userService) {
            this.userService= userService; //保存的service接口
            this.users= users; //你要保存的List集合
        }
        
        @Override
        protected void compute() {
        
            int size = users.size(); //本次處理大小
            
            if (size <= MAX_STRIDE) { //如果小于設(shè)定閾值，直接保存
                userService.saveBatch(temp);
            } else {        // 如果大于，將任務(wù)拆分，分而治之。
                int middle = (size) / 2;
                
                SumRecursiveTask left = new SumRecursiveTask(temp.subList(0, middle), userService);
                SumRecursiveTask right = new SumRecursiveTask(temp.subList(middle, size), userService);
               
               left.fork();   // 提交左任務(wù)（非阻塞）
                right.fork(); // 也可直接執(zhí)行rightTask.compute()
            }
        }
    }

import java.util.concurrent.RecursiveTask;

// 計算數(shù)組總和的任務(wù)（有返回值，用 RecursiveTask）
class SumTask extends RecursiveTask<Integer> {
    // 任務(wù)拆分的閾值：當(dāng)數(shù)組長度 <= 2 時，直接計算（不再拆分）
    private static final int THRESHOLD = 2;
    private int[] array; // 目標(biāo)數(shù)組
    private int start;   // 起始索引
    private int end;     // 結(jié)束索引（不包含）

    public SumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int length = end - start;
        // 若任務(wù)足夠小（小于閾值），直接計算結(jié)果
        if (length <= THRESHOLD) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            System.out.println("直接計算：" + start + "~" + end + "，結(jié)果=" + sum);
            return sum;
        }

        // 否則，拆分任務(wù)（Fork）
        int mid = (start + end) / 2;
        SumTask leftTask = new SumTask(array, start, mid);  // 左半部分任務(wù)
        SumTask rightTask = new SumTask(array, mid, end);   // 右半部分任務(wù)

        // 執(zhí)行子任務(wù)（fork() 會將任務(wù)提交到線程池，可能并行執(zhí)行）
        leftTask.fork();  // 拆分左任務(wù)
        rightTask.fork(); // 拆分右任務(wù)

        // 合并子任務(wù)結(jié)果（join() 會等待子任務(wù)完成并獲取結(jié)果）
        int leftResult = leftTask.join();
        int rightResult = rightTask.join();
        int total = leftResult + rightResult;
        System.out.println("合并：" + start + "~" + end + "，左=" + leftResult + "，右=" + rightResult + "，總=" + total);
        return total;
    }
}

import java.util.concurrent.ForkJoinPool;

public class ForkJoinDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
        // 創(chuàng)建 ForkJoinPool（默認(rèn)并行度為 CPU 核心數(shù)，這里假設(shè)為 2 個核心）
        try (ForkJoinPool pool = new ForkJoinPool()) {
            // 提交根任務(wù)（計算整個數(shù)組的和）
            SumTask rootTask = new SumTask(array, 0, array.length);
            int result = pool.invoke(rootTask); // 阻塞等待結(jié)果
            System.out.println("最終總和：" + result); // 輸出 36
        }
    }
}