Fork/Join

首先弄清楚ForkJoin的作用是什么?为什么会使用它?

Fork/Join是体现一个分而治之思想的任务框架

在多线程的情况下,使用forkjoin会提高工作效率,比如说多线程中有几个线程同时在执行任务,但是有的线程会先执行完毕,但是如果闲置这个已经跑完的线程就会造成资源上的浪费,如果让这个已经跑完的线程去帮助执行其他线程没执行完的任务,就可以减少整体的运行时间.

同时要知道,Fork和Join是两种动作,Fork是拆分,Join是合并.
要想实现通过ForkJoin提高效率那应该怎么做?
1.首先通过ForkJoinPool来执行fork/join任务.这个ForkJoinPool和线程池类似
2.创建一个fork/join任务,将这个放入ForkJoinPool中
3.然后通过ForkJoinPool提交任务

例子:

/**
 * 分支与合并
 *  ForkJoin:工作窃取,在多线程的情况下,有某个线程已经执行完毕,可以去窃取其他线程没有执行完的任务(多线程是双端队列)
 *
 *  求超大数据量的 和 计算的任务
 *      使用ForkJoin:
 *          如何使用ForkJoin--------->通过ForkJoinPool
 */
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;
    }

/**
     /**
     * The main computation performed by this task.
     * @return the result of the computation
     *  protected abstract V compute();
     *      * @return
     *      */

    /**没有参数,只有返回值,通过ForkJoin来对数据进行计算*/
    @Override
    protected Long compute() {

         if ((end-start)<temp){//如果小于临界值就普通方法执行
             Long sum = 0L;
             for (Long i = start; i <= end; i++) {
                 sum += i;
             }
             return sum;
         }else {
             long middle1 = (end + start) / 3;//两数的中间值
             long middle2 = (end + start) / 2;//两数的中间值
             ForkJoinDemo task1 = new ForkJoinDemo(start,middle1);//根据中间值把计算过程分为两部分
             task1.fork();
             ForkJoinDemo task2 = new ForkJoinDemo(middle1 + 1, middle2);
             task2.fork();
             ForkJoinDemo task3 = new ForkJoinDemo(middle2+1,end);
             task3.fork();
             return task1.join() + task2.join()+ task3.join();
         }


    }
}

测试计算同一个任务的几种方法的执行时间,通过下面的例子可以看出,使用stream并行流的方式是效率最高的,在数据量特别大的情况下使用fork/join也会对计算效率有提升,同时代码也更益维护

package functionInterface;

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


public class ForkJoinTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        test1();//test1()的计算结果是; 500000000500000000执行时间为:  6082
//        test2();//test2()的计算结果是; 500000000500000000执行时间为:  4680
        test3();//test3()的计算结果是; 500000000500000000执行时间为:  325
    }


    public static void test1(){
         Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= 1000000000; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("test1()的计算结果是; " + sum + "执行时间为:  " + (end-start));
    }

    /**
     * 使用ForkJoin来计算和的值
     */
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();//创建ForkJoinPool用来执行ForkJoin任务
        ForkJoinTask<Long> task = new ForkJoinDemo(0L,1000000000L);//创建一个ForkJoin任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交ForkJoin任务

        Long sum = submit.get();//获取返回值

        long end = System.currentTimeMillis();
        System.out.println("test2()的计算结果是; " + sum + "执行时间为:  " + (end-start));
    }

    /**
     * 使用stream并行流计算
     * parallel()========并行,这个是自动
     * reduce 规约
     */
    public static void test3(){
        long start = System.currentTimeMillis();
        long sum = LongStream.rangeClosed(0L, 1000000000L).parallel().reduce(0L, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("test3()的计算结果是; " + sum + "执行时间为:  " + (end-start));
    }
}