多线程 ForkJoinPool

背景：ForkJoinPool的优势在于，可以充分利用多cpu，多核cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器核心上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来即可。这种思想值得学习。

介绍

Java7 提供了ForkJoinPool来支持将一个任务拆分成多个“小任务”并行计算，再把多个“小任务”的结果合并成总的计算结果。

ForkJoinPool是ExecutorService的实现类，因此是一种特殊的线程池。

使用方法：创建了ForkJoinPool实例之后，就可以调用ForkJoinPool的submit(ForkJoinTask<T> task) 或invoke(ForkJoinTask<T> task)方法来执行指定任务了。

其中ForkJoinTask代表一个可以并行、合并的任务。ForkJoinTask是一个抽象类，它还有两个抽象子类：RecusiveAction和RecusiveTask。其中RecusiveTask代表有返回值的任务，而RecusiveAction代表没有返回值的任务。

下面的UML类图显示了ForkJoinPool、ForkJoinTask之间的关系：

案列一：通过多线程分多个小任务进行打印数据  无返回值的

package forkJoinPool;
 
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;
 
/**
 * @author liuchaojun
 * @date 2018-9-10 下午02:57:29
 * 
 * RecursiveAction  无返回值的
 * 
 */
public class PrintTask extends RecursiveAction {
 
    private static final long serialVersionUID = 1L;
    private static final int INDEX = 50;
    private int start;
    private int end;
 
    /**
     * 
     */
    public PrintTask(int start, int end) {
        // TODO Auto-generated constructor stub
        this.start = start;
        this.end = end;
    }
 
    /*
     * (non-Javadoc)
     * 
     * @see java.util.concurrent.RecursiveAction#compute()
     */
    @Override
    protected void compute() {
        if (end - start < INDEX) {
            for (int i = start; i < end; i++) {
                System.out.println(Thread.currentThread().getName() + "----"
                        + i);
            }
        } else {
            int middle = (end + start) / 2;
            PrintTask taskLeft = new PrintTask(start, middle);
            PrintTask taskRight = new PrintTask(middle, end);
            //taskLeft.invoke();执行给定的任务，在完成后返回其结果。
            //并行执行两个“小任务”
/*            taskLeft.fork();
            taskRight.fork();*/
            invokeAll(taskLeft, taskRight);//执行给定的任务
        }
    }
 
    public static void main(String[] args) throws InterruptedException {
        PrintTask task = new PrintTask(0, 300);
        ForkJoinPool pool = new ForkJoinPool();
        pool.submit(task);
        pool.awaitTermination(2, TimeUnit.SECONDS);//阻塞2秒
        pool.shutdown();
    }
}

运行结果

本机电脑cpu4核，通过上面观察线程名称，可以看出4个cpu都在进行

 

案列二：通过多线程分多个小任务进行数据累加  返回结果集

package com.pinyougou.test.multithreading;

import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;

public class PrintTask2 {
    public static void main(String[] args) throws Exception {
        int[] arr = new int[200];
        Random r = new Random();
        int tempSum = 0;// 普通总数
        for (int i = 0; i < arr.length; i++) {
            tempSum += (arr[i] = r.nextInt(10));
        }
        System.out.println("普通总数结果为:" + tempSum);

        ForkJoinPool pool = new ForkJoinPool();
        MyTask task = new MyTask(0, arr.length, arr);
        Future<Integer> sum = pool.submit(task);
        System.out.println("多线程的执行结果：" + sum.get());// get 如果需要，等待计算完成，然后检索其结果。
        pool.awaitTermination(2, TimeUnit.SECONDS);
        pool.shutdown(); // 关闭线程池
    }
}

class MyTask extends RecursiveTask<Integer> {
    private static final long serialVersionUID = 1L;
    private static final int INDEX = 50;// 每个小任务执行50个
    private int start;
    private int end;
    private int arr[];

    /**
     * @param start
     * @param end
     * @param arr
     */
    public MyTask(int start, int end, int[] arr) {

        this.start = start;
        this.end = end;
        this.arr = arr;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.util.concurrent.RecursiveTask#compute()
     */
    @Override
    protected Integer compute() {
        int sum = 0;
        if (end - start < INDEX) {
            for (int i = start; i < end; i++) {
                sum += arr[i];
            }
            return sum;
        } else {
            int middle = (end + start) / 2;
            MyTask taskLeft2 = new MyTask(start, middle, arr);
            MyTask taskRight2 = new MyTask(middle, end, arr);
            //invokeAll(taskLeft2, taskRight2);
            taskLeft2.fork();
            taskRight2.fork();
            int leftValue = taskLeft2.join();// 当计算完成时返回计算结果。
            int rightValue = taskRight2.join();
            return leftValue + rightValue;
        }
    }
}

运行结果： 

提供一些API 的方法，可以参考下

总结

1，invokeAll(task)方法，主动执行其它的ForkJoinTask，并等待Task完成。（同步的）

2，fork方法，让一个task执行（异步的）

3，join方法，让一个task执行（同步的，它和fork不同点是同步或者异步的区别）

4，可以使用join来取得ForkJoinTask的返回值。由于RecursiveTask类实现了Future接口，所以也可以使用get()取得返回值。 
get()和join()有两个主要的区别： 
join()方法不能被中断。如果你中断调用join()方法的线程，这个方法将抛出InterruptedException异常。 
如果任务抛出任何未受检异常，get()方法将返回一个ExecutionException异常，而join()方法将返回一个RuntimeException异常。

5，ForkJoinTask在不显示使用ForkJoinPool.execute/invoke/submit()方法进行执行的情况下，也可以使用自己的fork/invoke方法进行执行。 
使用fork/invoke方法执行时，其实原理也是在ForkJoinPool里执行，只不过使用的是一个“在ForkJoinPool内部生成的静态的”ForkJoinPool。

6，ForkJoinTask有两个子类，RecursiveAction和RecursiveTask。他们之间的区别是，RecursiveAction没有返回值，RecursiveTask有返回值。

7，看看ForkjoinTask的Complete方法的使用场景 
这个方法好要是用来使一个任务结束。这个方法被用在结束异步任务上，或者为那些能不正常结束的任务，提供一个选择。

8，Task的completeExceptionally方法是怎么回事。 
这个方法被用来，在异步的Task中产生一个exception，或者强制结束那些“不会结束”的任务 
这个方法是在Task想要“自己结束自己”时，可以被使用。而cancel方法，被设计成被其它TASK调用。 
当你在一个任务中抛出一个未检查异常时，它也影响到它的父任务（把它提交到ForkJoinPool类的任务）和父任务的父任务，以此类推。

9，可以使用ForkJoinPool.execute(异步，不返回结果)、invoke(同步，返回结果)、submit(异步，返回结果)方法，来执行ForkJoinTask。

10，ForkJoinPool有一个方法commonPool()，这个方法返回一个ForkJoinPool内部声明的静态ForkJoinPool实例。 在jdk1.8里面才有。文档上说，这个方法适用于大多数的应用。这个静态实例的初始线程数，为“CPU核数-1 ”（Runtime.getRuntime().availableProcessors() - 1）。 
ForkJoinTask自己启动时，使用的就是这个静态实例。