带返回值多线程任务执行

package com.demo.config;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;

/**
 * @author hutf
 * @createTime 2022年08月28日 16:40:00
 */
public class RecursiveTaskImpl extends RecursiveTask<Integer> {


    private static final long serialVersionUID = 1L;
    // 定义一个分解任务的阈值——50,即一个任务最多承担50个工作量
    private int THRESHOLD = 5;
    // 任务量
    private int task_Num = 0;

    private List<String> task_List;

    RecursiveTaskImpl(int Num) {
        this.task_Num = Num;
    }

    public RecursiveTaskImpl(List<String> task_List) {
        this.task_List = task_List;
        this.task_Num = task_List.size();
    }


    @Override
    protected Integer compute() {
        int j = 0;
        if (task_Num <= THRESHOLD) {
            System.out.println(
                    Thread.currentThread().getName() + "承担了" + task_Num + "份工作");
            try {
                for (String s : task_List) {
                    System.out.println(Thread.currentThread().getName() + " 正执行" + s);
                    j++;
                }
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
//            // 随机解成两个任务
//            Random m = new Random();
//            int x = m.nextInt(THRESHOLD);
//
//            ForkJoinPoolBatch left = new ForkJoinPoolBatch(x);
//            ForkJoinPoolBatch right = new ForkJoinPoolBatch(task_Num - x);
//
//            left.fork();
//            right.fork();


            // 随机解成两个任务
            Random m = new Random();
            int x = m.nextInt(THRESHOLD);

            List<String> leftTask = task_List.subList(0, x);
            List<String> rightTask = task_List.subList(x, task_List.size());

            RecursiveTaskImpl left = null;
            RecursiveTaskImpl right = null;

            if (leftTask.size() > 0) left = new RecursiveTaskImpl(leftTask);
            if (rightTask.size() > 0) right = new RecursiveTaskImpl(rightTask);

            if (left != null){
                ForkJoinTask<Integer> fork = left.fork();
                Integer join = fork.join();
                j += join;
            }

            if (right != null) {
                ForkJoinTask<Integer> fork = right.fork();
                Integer join = fork.join();
                j += join;
            }

            return j;
        }
        return j;
    }

    public static void main(String[] args) throws Exception {

        List<String> list = new ArrayList<>();

        for (int i = 0; i < 100; i++) {
            String s = UUID.randomUUID().toString().replaceAll("-", "");
            list.add(String.format("INSERT INTO `db_0`.`user` (`id`, `name`) VALUES (\'%s\', \'%s\') ", s, "name" + i));
        }


        // 创建一个支持分解任务的线程池ForkJoinPool
        ForkJoinPool pool = new ForkJoinPool(1);
        RecursiveTaskImpl task = new RecursiveTaskImpl(list);

        ForkJoinTask<Integer> submit = pool.submit(task);
        Integer join = submit.join();

        System.out.println("result is :");
        System.out.println(join);

//        pool.awaitTermination(1, TimeUnit.SECONDS);// 等待20s，观察结果
        pool.shutdown();

    }
}