JUC学习笔记六：ForkJoin

ForkJoin

1.forkjoin原理

fork join是在jdk1.7开发出来，他的原理的就是提供并行的任务，提高效率。
在大数据量的前提下，把一个任务拆分成多个任务去执行，再把多个任务的结果汇总起来成为最终的结果

2.forkjoin工作特点

工作窃取

假设有两个任务运行，A任务运行到一半阻塞了，B任务运行完了，那么这时候B任务就会把A任务接过来运行，提高运行的效率
这个里面使用的就是双端队列

3.forkjoin的使用

使用的时候需要继承RecursiceTask

package com.ycm.forkjoin;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
 * 计算求和任务
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;
    private Long end;

    private Long temp = 10000L; //临界值

    public ForkJoinDemo(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if ((end - start) < temp) {
            Long sum = 0L;
            for (Long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            Long mid = (start + end) / 2;
            ForkJoinDemo task1 = new ForkJoinDemo(start, mid);
            task1.fork();//拆分任务，把任务压入线程队列中
            ForkJoinDemo task2 = new ForkJoinDemo(mid + 1, end);
            task2.fork();
            return task1.join() + task2.join(); //把任务合并
        }

    }
}

class test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1();//运行时间：8171
        //test2(); //运行时间：7745
        test3(); //运行时间：380
    }

    /**
     * 常规计算
     */
    public static void test1() {
        Long start = System.currentTimeMillis();
        Long sum = 0L;
        for (Long i = 1L; i <= 10_0000_0000; i++) {
            sum += i;
        }
        Long end = System.currentTimeMillis();
        Long time = end - start;
        System.out.println("结果：" + sum + "  运行时间：" + time);
    }

    /**
     *使用forkjoin计算
     */
    public static void test2() throws ExecutionException, InterruptedException {
        Long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(1L, 10_0000_0000L);
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();
        Long end = System.currentTimeMillis();
        Long time = end - start;
        System.out.println("结果：" + sum + "  运行时间：" + time);
    }

    /**
     * 使用流式分布式计算
     */
    public static void test3() {
        Long start = System.currentTimeMillis();
        long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
        Long end = System.currentTimeMillis();
        Long time = end - start;
        System.out.println("结果：" + sum + "  运行时间：" + time);
    }
}

得出结果：

1. 使用常规计算，运行速度慢，效率低
2. 使用forkjoin相对常规计算速度快些，而且参数可调
3. 使用stream流式计算效率最高，代码简洁