ForkJoin框架

ForkJoin是jdk7以后加入的，它的作用是对一个大任务进行拆分，可以无限拆分，若需要返回结果，则进行合并。

需要继承ForkJoinTask的子类：

RecursiveTask：需要返回结果的

RecursiveAction：不需要返回结果的

需要定义域值，也就是判断什么时候开始拆分，定义拆分的规则，比如二分法等等

下面是一个例子：等差数列求和：1+3+5+9+……+199=?

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

/**
 * ForkJoin实现 1 3 5 7 9 ... 199等差数列的求和
 */
public class UseForkJoin extends RecursiveTask<Integer>{
	//定义一个域值 也就是任务中是最小值和最大值的差不能大于几，大于则拆分
	private static int holdNum = 4; 
	//每一个任务的初始值
	private int start;
	//每一个任务的结束值
	private int end;
	
	public UseForkJoin(int start,int end) {
		this.start = start;
		this.end = end;
	}
	@Override
	protected Integer compute() {
		//定义返回的求和
		int sum = 0;
		if(end - start <=holdNum) {
			for(int i = start;i <= end;i+=2) {
				sum += i;
			}
		}else {
			//利用二分法
			//初始值是第几项
			int startIndex = (start+1)/2;
			//结束值是第几项
			int endIndex = (end+1)/2;
			//中间值的index
			int middleIndex = (endIndex + startIndex)/2;
			//中间值
			int middle = 2*middleIndex-1;
			UseForkJoin leftTask = new UseForkJoin(start,middle);
			UseForkJoin rightTask = new UseForkJoin(middle+2,end);
			//每一个小任务进行拆分
			leftTask.fork();
			rightTask.fork();
			//对每一个任务结果进行合并计算
			int leftResult = leftTask.join();
			int rightResult = rightTask.join();
			sum = leftResult + rightResult;
		}
		return sum;
	}

	public static void main(String[] args) {
		ForkJoinPool pool = new ForkJoinPool();
		UseForkJoin task = new UseForkJoin(1, 199);
		Future<Integer> result = pool.submit(task);
		try {
			System.err.println("求和结果为：" + result.get());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (ExecutionException e) {
			e.printStackTrace();
		}
	}
}

结果：