Java并发-Fork/Join框架

Fork/Join框架中的主要类：

1. ForkJoinTask<V>: 描述任务的抽象类

2. ForkJoinPool: 管理ForkJoinTask的线程池

3. RecursiveAction: ForkJoinTask子类，描述无返回值的任务

4. RecursiveTask<V> : ForkJoinTask子类，描述有返回值的任务

Fork/Join框架：分而治之策略

1. 将任务递归划分成更小的子任务，直到子任务足够小，从而能够被连续快速的处理掉为止

2. 优势是处理过程可以使用并行发生，这种情况特别适合基于多核处理器的并行编程

3. 根据Java API中的定义，分而治之的建议临界点定义在 100 - 1000 个操作中的某个值

以下使用该框架计算0-100000的和：

package com.concurrent.src;

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

public class Fdemo {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		Future<Long> result = forkJoinPool.submit(new MTask(0,100000));
		System.out.println("最终结果为：" + result.get());
		forkJoinPool.shutdown();
	}
}

class MTask extends RecursiveTask<Long>{
	
	private static final long serialVersionUID = 1L;
	// 阈值
	static final int THRESHOLD = 1000;
	private int begin,end;
	public MTask(int begin,int end) {
		this.begin = begin;
		this.end = end;
	}
	
	@Override
	protected Long compute() {// 每个任务处理数量在1000个以内
		long sum = 0;
		// 任务足够小就自己处理，大的话fork处理
		if(end - begin <= THRESHOLD) {
			for (int i = begin; i <= end; i++) {
				sum += i;
			}
		} else {// 递归拆分为两个任务
			int mid = (begin + end) / 2;
			System.out.println("===" + mid);
			MTask left = new MTask(begin,mid);
			left.fork();
			
			MTask right = new MTask(mid,end);
			right.fork();
			
			Long lr = left.join();
			System.out.println(begin + "-" + mid + ":" + lr);
			
			Long rr = right.join();
			System.out.println(mid + "-" + end + ":" + rr);
			
			sum = lr + rr;
		}
		return sum;
	}
}