Fork/Join框架 组成成分 与 代码示例

JDK1.7推出，用于并行执行任务：将一个大人物分割成若干小任务，最终汇总每个小任务的结果得到大任务的结果。
主要分两步：任务分割；结果合并。

API介绍：
    (1)ForkJoinPool：线程池

    (2)ForkJoinTask：任务，即自定义一个任务类，继承RecursiveAction\RecursiveTask，重写compute()方法

ForkJoinTask中的主要方法：
    * fork()    在当前线程运行的线程池中安排一个异步执行。简单的理解就是再创建一个子任务。
    * join()    当任务完成的时候返回计算结果。
    * invoke()    开始执行任务，如果必要，等待计算完成。

    子类：
    * RecursiveAction    一个递归无结果的ForkJoinTask（没有返回值）
    * RecursiveTask    一个递归有结果的ForkJoinTask（有返回值）

    (3)ForkJoinWorkerThread：线程池中一个执行任务的线程

 

 

Executor框架中学习的线程池 和 ForkJoin框架中的ForkJoinPool的区别：
ForkJoinPool线程池中每个线程都单独拥有一个工作队列，当自己队列中的任务都完成后，该线程会从其他线程的工作队列中窃取一个任务执行(窃取是Fork/Join框架与Executor框架中线程池的最主要区别，另一个是队列，下面跟着会讲队列)，这样可以充分利用线程进行并行计算，利用空闲时间，充分利用资源。
当A线程去B线程的队列中窃取任务时（某任务在B线程的队列中，说明这个任务已经分配给B线程了，A这时想偷过来），A B可能同时访问该同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常工作队列使用的是双端队列，被窃取任务线程永远从队头拿任务，窃取任务线程永远从队尾拿任务，减少了线程间竞争，缺点是在某些情况下还是存在竞争，比如双端队列中只有一个任务，另外也消耗了更多资源（多个队列，且还是双端队列）。
（此处ForkJoinPool线程池中线程与队列的关系  与  Executor框架中ThreadPoolExecutor线程池中线程与阻塞队列（BlockingQueue）的关系有很大不同，
Executor框架中是所用线程共用一个工作队列（堵塞队列），所有线程都从这个工作队列中取任务）

而ForkJoinPool：
使用一种分治算法，递归地将任务分割成更小的子任务，其中阈值可配置，然后把子任务分配给不同的线程执行并发执行，最后再把结果组合起来。该用法常见于数组与集合的运算。
由于提交的任务不一定能够递归地分割成ForkJoinTask，且ForkJoinTask执行时间不等长，所以ForkJoinPool使用一种工作窃取的算法，允许空闲的线程“窃取”分配给另一个线程的工作。由于工作无法平均分配并执行。所以工作窃取算法能更高效地利用硬件资源。

总结一下，这么记：正常的都是一般线程池共用一个阻塞队列，线程数达到核心线程时，就往阻塞队列里让任务......               
                                而fork/join框架为了任务窃取这么一个东西，就需要每个线程维护一个阻塞队列。

 

从前面知道了线程池和工作队列的关系，从源码角度来看，WorkQueue是ForkJoinPool的内部类，WorkQueue是线程池中线程的工作队列的一个封装，支持任务窃取

和Executor框架一样，由线程池调用execute()/submit()方法，提交任务到当前提交者的任务队列中。
execute()不返回结果，submit()返回结果。

注意：（Executor框架的上面两个方法的参数是线程，而Fork/Join框架的上面两个方法的参数是自定义task任务（即继承了RecursiveAction或RecursiveTask的自定义类）） 感觉这句话不太对？？正解：参数都是自定义任务，而非线程

 

ForkJoinWorkerThread类中有所在线程池和对应的工作队列的引用，靠两个引用将三者联系在一起：

public class ForkJoinWorkerThread extends Thread {
    ......
    // the pool this thread works in
    final ForkJoinPool pool;

    // work-stealing mechanics
    final ForkJoinPool.WorkQueue workQueue;
    ......
}

 

demo1：批量发送消息

无返回

//在compute()中直接用invokeAll()，而没有用fork()   （和返不返回没关系）

public class ForkJoinPoolDemo {
    class SendMsgTask extends RecursiveAction {
        private final int THRESHOLD = 10;
        private int start;
        private int end;
        private List<String> list;
        public SendMsgTask(int start, int end, List<String> list) {
            this.start = start;
            this.end = end;
            this.list = list;
        }
        @Override
        protected void compute() {
            if ((end - start) <= THRESHOLD) {
                for (int i = start; i < end; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + list.get(i));
                }
            }else {
                int middle = (start + end) / 2;
                invokeAll(new SendMsgTask(start, middle, list), new SendMsgTask(middle, end, list)); //这行代码可以理解成left.fork() 和 right.fork()
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 123; i++) {
            list.add(String.valueOf(i+1));
        }
        ForkJoinPool pool = new ForkJoinPool();
        pool.execute(new ForkJoinPoolDemo().new SendMsgTask(0, list.size(), list)); //经实验，submit也可以 （因为只有execute不能和Callable(即有返回值的)匹配）
        pool.awaitTermination(10, TimeUnit.SECONDS); 
        pool.shutdown();
    }
}

 

demo2：求和
有返回
//在compute()中使用fork+ return join    （和返不返回没关系）

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
public class ForkJoinTaskDemo {
    private class SumTask extends RecursiveTask<Integer> {
        private static final int THRESHOLD = 20;
        private int arr[];
        private int start;
        private int end;
        public SumTask(int[] arr, int start, int end) {
            this.arr = arr;
            this.start = start;
            this.end = end;
        }
        /**
         * 小计
         */
        private Integer subtotal() {
            Integer sum = 0; //注意，sum是定义在compute()方法里，而非自定义任务的成员变量里的
            for (int i = start; i < end; i++) {
                sum += arr[i];
            }
            System.out.println(Thread.currentThread().getName() + ": ∑(" + start + "~" + end + ")=" + sum);
            return sum;
        }
        @Override
        protected Integer compute() {
            if ((end - start) <= THRESHOLD) {
                return subtotal();
            }else {
                int middle = (start + end) / 2;
                SumTask left = new SumTask(arr, start, middle);
                SumTask right = new SumTask(arr, middle, end);
                //下面两行代码可以理解成invokeAll(left,right)
                left.fork();
                right.fork(); 
                return left.join() + right.join();

                //换一种写法
                invokeAll(left,right);
                Integer left = left.join();
                Integer right = right.join();
                return left + right;
            }
        }
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        int[] arr = new int[100];
        for (int i = 0; i < 100; i++) {
            arr[i] = i + 1;
        }
        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Integer> result = pool.submit(new ForkJoinTaskDemo().new SumTask(arr, 0, arr.length));
/*
1. execute(ForkJoinTask) 异步执行tasks，无返回值
2. submit(ForkJoinTask) 异步执行，且带Task返回值，可通过task.get 实现同步到主线程
3. invoke(ForkJoinTask) 有Join, tasks会被同步到主进程
*/

        System.out.println("最终计算结果: " + result.invoke());
        pool.shutdown();
    }
}

 

 

---

讲一下需要用户自定义的任务类Test：

ForkJoinTask是个抽象类，用户无须直接继承该类，可以根据compute()方法是否返回值，继承ForkJoinTask的抽象子类RecursiveAction 或 RecursiveTask
ForkJoinTask出现在当forkJoinPool线程池执行继承自RecursiveTask（即有返回的）任务后，作为返回数据存在：
ForkJoinTask<Integer> result = pool.submit(new ForkJoinTaskDemo().new SumTask(arr, 0, arr.length));

private static class SumTask extends RecursiveTask<Integer> {
        private  int threshold ;
        private static final int segmentation = 10;
        private int[] src;
        private int fromIndex;
        private int toIndex;
        public SumTask(int formIndex,int toIndex,int[] src){
            this.fromIndex = formIndex;
            this.toIndex = toIndex;
            this.src = src;
            this.threshold = src.length/segmentation;
        }
        @Override
        protected Integer compute() {
            if((toIndex - fromIndex)<threshold ){
                int count = 0;
                System.out.println(" from index = "+fromIndex
                        +" toIndex="+toIndex);
                for(int i = fromIndex;i<=toIndex;i++){
                  count+=src[i];
                }
                return count;
            }else{
                int mid = (fromIndex+toIndex)/2;
                SumTask left =  new SumTask(fromIndex,mid,src);
                SumTask right = new SumTask(mid+1,toIndex,src);
                invokeAll(left,right); //这行代码可以理解成left.fork() 和 right.fork()
                /*
                在fork/join模式中，我们在子任务中常常使用fork方法来让子任务采取异步方法执行，但是这不是高效的实现方法，尤其是对于forkjoinPool在线程有限的情况下，子任务直接使用fork方法执行时
                间比使用invokeAll执行时间要长。下面分析一下原理：

                对于fork/join模式，假如pool里面线程数量是固定的，那么调用子任务的fork方法相当于A先分工给B，然后A当监工不干活，B去完成A交代的任务。所以上面的模式相当于浪费了一个线程。那么如
                果使用invokeAll相当于A分工给B后，A和B都去完成工作。这样缩短了执行的时间。
                */

                return left.join()+right.join();
            }
        }
    }

 

 

---

看了上面三个例子后的总结：
有返回，则compute()方法的函数类型跟着变。

在compute()内部以

left.fork();
right.fork();
//或 invokeAll(left,right);

return left.join()+right.join();

 

在main()方法里：

pool.execute(action);
/*
或 ForkJoinTask<T> result = pool.submit(task);
   result.invoke();  //get()也可以
*/

 

自己写的代码

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


/*
计算1+2+...+1000，并输出结果。
设置阈值为10，即把求和分为100个子任务。
*/
public class SumTask extends RecursiveTask<Integer> {

    private static final int THRESHOLD = 2;
    private int start;
    private int end;
//    private int arr[];

    public SumTask(int start, int end){
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        if (end - start <= THRESHOLD){
            for (int i = start;i<end;i++){
                sum += i;
            }
            return sum;
        }else {
            int middle = (end+start)/2;
            SumTask leftTask = new SumTask(start,middle);
            SumTask rightTask = new SumTask(middle,end);
//            invokeAll(leftTask, rightTask);
            leftTask.fork();
            rightTask.fork();
            int left = leftTask.join();
            int right = rightTask.join();
            sum =  (left + right);
            return  sum;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        SumTask sumTask = new SumTask(1, 1000);
        ForkJoinTask<Integer> result = forkJoinPool.submit(sumTask);
        System.out.println(result.get());
    }
}