Java多线程ForkJoin并行框架详细解析

1.引言：

     现在，硬件的处理能力，基本处于水平发展，为了更好的提高性能，现在都是采用的多核CPU，尽可能的提升并发性能，但是有一个问题是程序的本身并发处理能力不强，就会造成不能够合理的利用多核心资源，例如，多个线程运行时，一个CPU分配的任务较少，当该CPU完成其任务后，处于空闲状态，这就浪费了资源。

     在JDK7时，引入了ForkJoinPool，是一个线程池，其核心的思想是将一个大任务拆分成小任务，然后将每个小任务的结果汇总到一个结果上。它本身是一个线程池，其所支持的最大线程数，就是硬件的CPU的数量，是AbstractExecutorService的子类，并引入了“工作窃取算法”，使其在多线程并行处理的效果上更佳，如下图所示：

1.1 工作窃取算法

    work-stealing（工作窃取），ForkJoinPool提供了一个更有效的利用线程的机制，当ThreadPoolExecutor还在用单个队列存放任务时，ForkJoinPool已经分配了与线程数相等的队列，当有任务加入线程池时，会被平均分配到对应的队列上，各线程进行正常工作，当有线程提前完成时，会从队列的末端“窃取”其他线程未执行完的任务，当任务量特别大时，CPU多的计算机会表现出更好的性能。

2.常用方法：

   ForkJoin框架，必须先创建一个ForkJoin任务。它提供了分而治之的操作机制，即在提供的任务中执行fork()和join()的操作机制，通常我们不直接继承ForkJoinTask类，而是继承其两个子类：

   1. RecursiveTask<T>:用于有返回值结果的任务。

   2. RecursiveAction：用于没有返回结果的任务。

   ForkJoinPool ：ForkJoinTask需要通过ForkJoinPool来执行，任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

3.实例：

求一个数组中的最大值

比较了“常规算法”和“利用ForkJoin框架所需的时间”

package com.it.thread;

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

public class TestForkJoinMax {

	public static void main(String[] args) {
		 int[] data = new int[40000000];
		 Random random = new Random();
		 for(int i = 0 ;i<data.length;i++) {
			 data[i]=random.nextInt(100000000);
		 }
		 
		 System.out.println(findMax1(data));
		 System.out.println(findMax2(data));
	}
	
	static int findMax1(int data[]) {
		int max = data[0];
		long t1 = System.nanoTime();
		for(int i = 1;i<data.length;i++) {
			if (max<data[i]) {
				max=data[i];
			}
		}	
		long t2 = System.nanoTime();
		System.out.println(t2-t1);
		return max;	
	}
	
	
	static int findMax2(int data[]) {
		class MyFindMax extends RecursiveTask<Integer>{
			int data[];
			int start;//包含数组的起始下标
			int end;//不包含结束下标
			//设置一个阈值，当作条件进行大任务的拆分条件
			static final int THRESHOLD=100000;

			public MyFindMax(int[] data, int start, int end) {
				super();
				this.data = data;
				this.start = start;
				this.end = end;
			}



			@Override
			protected Integer compute() {
                                //小于阈值，直接利用常规算法，进行最大值寻找
				if (end-start<=THRESHOLD) {
					int max = data[start];
					for(int i = start+1;i<end;i++) {
						if (max<data[i]) {
							max=data[i];
						}
					}
					return max;
				}else {
                                        //如果大于阈值，进分裂成两个子任务处理
					int middle = (start+end)/2;
					MyFindMax task1 = new MyFindMax(data, start, middle);
					MyFindMax task2 = new MyFindMax(data, middle, end);                                   //执行两个子任务
					invokeAll(task1, task2);
                                        //获取子任务的返回值
					int result1 =task1.join();
					int result2 =task2.join();
					if (result2>result1) {
						return result2;				
					}else {
						return result1;
					}
				}
				
			}
			
		}
		long t1 = System.nanoTime();
                //创建ForkJoinPool 线程池
		ForkJoinPool pool = new ForkJoinPool();
		MyFindMax main = new MyFindMax(data, 0, data.length);
                //将大任务提交给线程池
		int result =  pool.invoke(main);
		long t2 = System.nanoTime();
		System.out.println(t2-t1);
		return result;
	}
}

 运行结果：

31780336
99999996
29180490
99999996

第一行：常规算法所需的时间（纳秒为单位）已经是最优的算法了

第二行：常规算法所计算的最大值

第三行：ForkJoin框架运算所需时间（纳秒为单位）

第四行：ForkJoin框架所计算的最大值

很明显可以看出ForkJoin并行框架使用的时间少，说明其并行运行的效率很高。

4.对ForkJoin框架的常见优化方法：

1.尽量选取一个适合的阈值。

2.分裂为子任务时，都需要创建对象，可以在此位置进行优化。