并发学习之ForkJoin

三种从一加到一亿的方法

1: 使用ForkJoin的准备工作：先创建一个类，继承RecursiveTask

public class ForkJoinTask extends RecursiveTask<Long> {

    private long start;

    private long end;

    //阈值
    private long tmp = 10000l;

    public ForkJoinTask(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        Long sum = 0l;
        if((end - start) < tmp){
            for(Long i = start; i <= end; i++){
                sum += i;
            }
            return sum;
        }else{
            //大于1000的情况下，使用ForkJoin
            Long middle = (end + start)/2;
            ForkJoinTask task1 = new ForkJoinTask(0l,middle);
            task1.fork();
            ForkJoinTask task2 = new ForkJoinTask(middle,end);
            task2.fork();
            return task1.join()+task2.join();
        }
    }
}

2: 三种方法的具体测试代码

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

//三种方法来尝试从一加到100000000的速度
//理论上是 Stream>ForkJoin>直接+
//但是我的电脑测试不理想(Stream>直接加>ForkJoin）

public class ForkDemo1 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.用程序得到CPU核数
        System.out.println(Runtime.getRuntime().availableProcessors());
        //2.对方法的测试
//        test1();
        test2();
//        test3();
    }

    //第一种：普通方法  ：经过试验：时间为451
    public static void test1(){
        long a = System.currentTimeMillis();
        long sum = 0l;
        for(long i = 0l; i < 10_0000_0000; i++){
            sum += i;
        }
        long b = System.currentTimeMillis();
        System.out.println("时间是: "+(b - a));
        System.out.println(sum);
    }

    //第二种： 使用ForkJoin :经过试验，我的四核电脑使用这个方法所需要的时间极为长久都没有反应
    public static void test2() throws ExecutionException, InterruptedException {

        long a = System.currentTimeMillis();

        //1.创建一个ForkJoinPool线程池
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        //2.实例化所需要处理的任务
        ForkJoinTask task = new ForkJoinTask(0l, 10_0000_0000l);
        //3.利用池对任务进行处理
        java.util.concurrent.ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        //4.得到处理的返回结果
        Long sum = submit.get();

        long b = System.currentTimeMillis();
        System.out.println("时间是: "+(b - a));
        System.out.println(sum);
    }

    //第三种: 使用 Stream并发流来对数据操作 ：经过试验：时间为351，比直接+的操作快
    public static void test3(){
        long a = System.currentTimeMillis();

        //流式编程骚操作，里面的方法自己慢慢悟吧
        long sum = LongStream.rangeClosed(0, 10_0000_0000l).parallel().reduce(0, Long::sum);

        long b = System.currentTimeMillis();
        System.out.println("时间是: "+(b - a));
        System.out.println(sum);
    }
}