ForkJoin的使用

ForkJoin的使用

第一种 无返回值的使用：异步处理线程

第一步：定义一个task，继承RecursiveTask，用于分组 和 每个线程对每个组的处理逻辑

@Component
@Slf4j
public class TaskForkJoin extends RecursiveTask<Void> {

    /**
     * 阀值,每组的大小
     */
    private static final Integer THRES_HOLD = 30;

    //要处理的数据
    private List records;

    public TaskForkJoin() {
    }

    public TaskForkJoin(List records) {
        this.records = records;
    }

    /**
     * 计算分组
     *
     * @return
     */
    @Override
    protected Void compute() {
        //每组30个
        if (records.size() <= THRES_HOLD) {
            computeDirectly();
            return null;
        }
        //如果要处理的数据大于等于30，则进行分组转换
        int size = records.size();
        //第一个分组
        TaskForkJoin aTask = new TaskForkJoin(records.subList(0, size / 2));
        //第二个分组
        TaskForkJoin bTask = new TaskForkJoin(records.subList(size / 2, records.size()));
        //两个任务并发执行起来
        invokeAll(aTask, bTask);

        return null;
    }


    /**
     * 真正处理数据的逻辑
     */
    private void computeDirectly() {
        //针对每组 处理的业务逻辑
        //这里的records的值，就是每组的值
    }
}

第二步 主线程中 创建 ForkJoinPool，并执行task

/**
 * 5:线程池中的线程数
 */
ForkJoinPool forkJoinPool = new ForkJoinPool(5); 
/**
 * list:需要处理的数据
 */
TaskForkJoin taskForkJoin = new TaskForkJoin(list); 
forkJoinPool.submit(taskForkJoin);

第二种 有返回值的使用：主线程等待线程执行完毕，并返回结果

第一步：定义一个task，继承RecursiveTask，用于分组 和 每个线程对每个组的处理逻辑

@Component
@Slf4j
public class TaskForkJoin extends RecursiveTask<Long> {

    /**
     * 阀值
     */
    private static final Integer THRES_HOLD = 30;

    //要处理的数据
    private List records;

    public TaskForkJoin() {
    }

    public TaskForkJoin(List records) {
        this.records = records;
    }

    /**
     * 计算分组
     *
     * @return
     */
    @Override
    protected Long compute() {
        //每组30个
        if (records.size() <= THRES_HOLD) {
            return computeDirectly();
        }
        //如果要处理的数据大于等于30，则进行分组转换
        int size = records.size();
        //第一个分组
        TaskForkJoin aTask = new TaskForkJoin(records.subList(0, size / 2));
        //第二个分组
        TaskForkJoin bTask = new TaskForkJoin(records.subList(size / 2, records.size()));
        //两个任务并发执行起来
        invokeAll(aTask, bTask);

        return aTask.join() + bTask.join();
    }


    /**
     * 真正处理数据的逻辑
     */
    private Long computeDirectly() {
        //针对每组 处理的业务逻辑
        //这里的records的值，就是每组的值
    }
}

第二步 主线程中 创建 ForkJoinPool，并执行task

/**
 * 5:线程池中的线程数
 */
ForkJoinPool forkJoinPool = new ForkJoinPool(5); 
/**
 * list:需要处理的数据
 */
TaskForkJoin taskForkJoin = new TaskForkJoin(list); 
ForkJoinTask<Long> submitResult = forkJoinPool.submit(taskForkJoin);