转https://www.cnblogs.com/lixuwu/p/7979480.html

阅读目录

• 使用

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

主要参考《疯狂java讲义》

回到顶部

使用

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

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

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

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

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

举例

以还行没有返回值的“大任务”（简单低打印1~300的数值）为例，程序将一个“大任务”拆分成多个“小任务”，并将任务交给ForkJoinPool来执行

1/**
2 * Project Name:Spring0725
3 * File Name:ForkJoinPoolAction.java
4 * Package Name:work1201.basic
5 * Date:2017年12月4日下午2:26:55
6 * Copyright (c) 2017, 深圳金融电子结算中心 All Rights Reserved.
7 *
8*/
9
10package work1201.basic;
11
12import java.util.concurrent.ForkJoinPool;
13import java.util.concurrent.RecursiveAction;
14import java.util.concurrent.TimeUnit;
15
16/**
17 * ClassName:ForkJoinPoolAction <br/>
18 * Function: 使用ForkJoinPool完成一个任务的分段执行
19 * 简单的打印0-300的数值。用多线程实现并行执行
20 * Date:     2017年12月4日 下午2:26:55 <br/>
21 * @author   prd-lxw
22 * @version   1.0
23 * @since    JDK 1.7
24 * @see      
25 */
26public class ForkJoinPoolAction {
27    
28    public static void main(String[] args) throws Exception{
29        PrintTask task = new PrintTask(0, 300);
30        //创建实例，并执行分割任务
31        ForkJoinPool pool = new ForkJoinPool();
32        pool.submit(task);
33         //线程阻塞，等待所有任务完成
34        pool.awaitTermination(2, TimeUnit.SECONDS);
35        pool.shutdown();
36    }
37}
38
39/**
40 * ClassName: PrintTask <br/>
41 * Function: 继承RecursiveAction来实现“可分解”的任务。
42 * date: 2017年12月4日 下午5:17:41 <br/>
43 *
44 * @author prd-lxw
45 * @version 1.0
46 * @since JDK 1.7
47 */
48class PrintTask extends RecursiveAction{
49    private static final int THRESHOLD = 50; //最多只能打印50个数
50    private int start;
51    private int end;
52    
53    
54
55    public PrintTask(int start, int end) {
56        super();
57        this.start = start;
58        this.end = end;
59    }
60
61
62
63    @Override
64    protected void compute() {
65        
66        if(end - start < THRESHOLD){
67            for(int i=start;i<end;i++){
68                System.out.println(Thread.currentThread().getName()+"的i值："+i);
69            }
70        }else {
71            int middle =(start+end)/2;
72            PrintTask left = new PrintTask(start, middle);
73            PrintTask right = new PrintTask(middle, end);
74            //并行执行两个“小任务”
75            left.fork();
76            right.fork();
77        }
78        
79    }
80    
81}

执行结果：

1ForkJoinPool-1-worker-1的i值：262
2ForkJoinPool-1-worker-7的i值：75
3ForkJoinPool-1-worker-7的i值：76
4ForkJoinPool-1-worker-5的i值：225
5ForkJoinPool-1-worker-3的i值：187
6ForkJoinPool-1-worker-6的i值：150
7ForkJoinPool-1-worker-6的i值：151
8ForkJoinPool-1-worker-6的i值：152
9ForkJoinPool-1-worker-6的i值：153
10ForkJoinPool-1-worker-6的i值：154
11......

因为我的电脑是i7处理器，一共8个cpu，观察线程的名称可以发现，8个cpu都在运行。

通过RecursiveTask的返回值，来对一个长度为100的数组元素进行累加。

1/**
2 * Project Name:Spring0725
3 * File Name:ForJoinPollTask.java
4 * Package Name:work1201.basic
5 * Date:2017年12月4日下午5:41:46
6 * Copyright (c) 2017, 深圳金融电子结算中心 All Rights Reserved.
7 *
8*/
9
10package work1201.basic;
11
12import java.util.Random;
13import java.util.concurrent.ForkJoinPool;
14import java.util.concurrent.Future;
15import java.util.concurrent.RecursiveTask;
16
17/**
18 * ClassName:ForJoinPollTask <br/>
19 * Function: 对一个长度为100的元素值进行累加
20 * Date:     2017年12月4日 下午5:41:46 <br/>
21 * @author   prd-lxw
22 * @version   1.0
23 * @since    JDK 1.7
24 * @see      
25 */
26public class ForJoinPollTask {
27
28    public static void main(String[] args) throws Exception {
29        int[] arr = new int[100];
30        Random random = new Random();
31        int total =0;
32        //初始化100个数组元素
33        for(int i=0,len = arr.length;i<len;i++){
34            int temp = random.nextInt(20);
35            //对数组元素赋值，并将数组元素的值添加到sum总和中
36            total += (arr[i]=temp);
37        }
38        System.out.println("初始化数组总和："+total);
39        SumTask task = new SumTask(arr, 0, arr.length);
40//        创建一个通用池，这个是jdk1.8提供的功能
41        ForkJoinPool pool = ForkJoinPool.commonPool();
42        Future<Integer> future = pool.submit(task); //提交分解的SumTask 任务
43        System.out.println("多线程执行结果："+future.get());
44        pool.shutdown(); //关闭线程池
45        
46        
47
48    }
49
50}
51
52/**
53 * ClassName: SumTask <br/>
54 * Function: 继承抽象类RecursiveTask，通过返回的结果，来实现数组的多线程分段累累加
55 *  RecursiveTask 具有返回值
56 * date: 2017年12月4日 下午6:08:11 <br/>
57 *
58 * @author prd-lxw
59 * @version 1.0
60 * @since JDK 1.7
61 */
62class SumTask extends RecursiveTask<Integer>{
63    private static final int THRESHOLD = 20; //每个小任务 最多只累加20个数
64    private int arry[];
65    private int start;
66    private int end;
67    
68    
69
70    /**
71     * Creates a new instance of SumTask.
72     * 累加从start到end的arry数组
73     * @param arry
74     * @param start
75     * @param end
76     */
77    public SumTask(int[] arry, int start, int end) {
78        super();
79        this.arry = arry;
80        this.start = start;
81        this.end = end;
82    }
83
84
85
86    @Override
87    protected Integer compute() {
88        int sum =0;
89        //当end与start之间的差小于threshold时，开始进行实际的累加
90        if(end - start <THRESHOLD){
91            for(int i= start;i<end;i++){
92                sum += arry[i];
93            }
94            return sum;
95        }else {//当end与start之间的差大于threshold，即要累加的数超过20个时候，将大任务分解成小任务
96            int middle = (start+ end)/2;
97            SumTask left = new SumTask(arry, start, middle);
98            SumTask right = new SumTask(arry, middle, end);
99            //并行执行两个 小任务
100            left.fork();
101            right.fork();
102            //把两个小任务累加的结果合并起来
103            return left.join()+right.join();
104        }
105        
106    }
107    
108}

执行结果：

1初始化数组总和：1008
2多线程执行结果：1008

分析

在Java 7中引入了一种新的线程池：ForkJoinPool。

它同ThreadPoolExecutor一样，也实现了Executor和ExecutorService接口。它使用了一个无限队列来保存需要执行的任务，而线程的数量则是通过构造函数传入，如果没有向构造函数中传入希望的线程数量，那么当前计算机可用的CPU数量会被设置为线程数量作为默认值。

ForkJoinPool主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题。典型的应用比如快速排序算法。

这里的要点在于，ForkJoinPool需要使用相对少的线程来处理大量的任务。

比如要对1000万个数据进行排序，那么会将这个任务分割成两个500万的排序任务和一个针对这两组500万数据的合并任务。以此类推，对于500万的数据也会做出同样的分割处理，到最后会设置一个阈值来规定当数据规模到多少时，停止这样的分割处理。比如，当元素的数量小于10时，会停止分割，转而使用插入排序对它们进行排序。

那么到最后，所有的任务加起来会有大概2000000+个。问题的关键在于，对于一个任务而言，只有当它所有的子任务完成之后，它才能够被执行。

所以当使用ThreadPoolExecutor时，使用分治法会存在问题，因为ThreadPoolExecutor中的线程无法像任务队列中再添加一个任务并且在等待该任务完成之后再继续执行。而使用ForkJoinPool时，就能够让其中的线程创建新的任务，并挂起当前的任务，此时线程就能够从队列中选择子任务执行。

以上程序的关键是fork()和join()方法。在ForkJoinPool使用的线程中，会使用一个内部队列来对需要执行的任务以及子任务进行操作来保证它们的执行顺序。

那么使用ThreadPoolExecutor或者ForkJoinPool，会有什么性能的差异呢？

首先，使用ForkJoinPool能够使用数量有限的线程来完成非常多的具有父子关系的任务，比如使用4个线程来完成超过200万个任务。但是，使用ThreadPoolExecutor时，是不可能完成的，因为ThreadPoolExecutor中的Thread无法选择优先执行子任务，需要完成200万个具有父子关系的任务时，也需要200万个线程，显然这是不可行的。

ps：ForkJoinPool在执行过程中，会创建大量的子任务，导致GC进行垃圾回收，这些是需要注意的。