JAVA fork/join详解

1. 什么是fork/join框架

        fork/join框架相当于一个map/reduce的过程，先将一个大的任务分解成几个小模块，再将几个小模块继续分解成子模块，直到达到可以处理的阈值，最后再将各个子模块的结果进行汇总。

        在fork过程中，先将大的任务分解为几个子任务。各个子任务之间是相互独立的双端队列，由各个子线程独自执行，执行完后将执行结果进行汇总。

2. 工作窃取算法

        上面提到各个子任务是放在独立的双端队列中，如果现在有一个队列中的已执行完毕，那这个线程就空闲出来了，如果其他队列还有数据，那这个空闲的线程可以去读取那个队列中尾端的数据进行执行。因为各个线程执行的时候，队列都是独立的，那各个线程之间不会存在竞争，这里在窃取其他队列中的数据进行执行的时候，由于是从尾端读取，也不会存在很大的竞争，但也不能完全消除竞争。

3. 核心类

        从上面描述可以知道，fork/join主要分为三步：

第一步：将一个大的任务分解成多个小任务

第二步：执行各个子任务。分解的子任务放在各个双端队列中，启动相应的子线程分别从双端队列中获取任务执行。

第三步：合并第二步各个子任务的结果。各个子任务的执行结果都统一放在一个队列里，启动一个线程进行合并操作。

ForkJoinTask:用来创建一个ForkJoin任务，它提供fork（）和join（）的执行机制。这个抽象类有两个实现类，

        RecursiveTask：用户返回有结果的任务

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

public abstract class RecursiveTask<V> extends ForkJoinTask<V> {
    private static final long serialVersionUID = 5232453952276485270L;

    /**
     * The result of the computation.
     */
    V result;

    /**
     * The main computation performed by this task.
     * @return the result of the computation
     */
    protected abstract V compute();

    public final V getRawResult() {
        return result;
    }

    protected final void setRawResult(V value) {
        result = value;
    }

    /**
     * Implements execution conventions for RecursiveTask.
     */
    protected final boolean exec() {
        result = compute();
        return true;
    }

}

public abstract class RecursiveAction extends ForkJoinTask<Void> {
    private static final long serialVersionUID = 5232453952276485070L;

    /**
     * The main computation performed by this task.
     */
    protected abstract void compute();

    /**
     * Always returns {@code null}.
     *
     * @return {@code null} always
     */
    public final Void getRawResult() { return null; }

    /**
     * Requires null completion value.
     */
    protected final void setRawResult(Void mustBeNull) { }

    /**
     * Implements execution conventions for RecursiveActions.
     */
    protected final boolean exec() {
        compute();
        return true;
    }

}

ForkJoinPool：ForkJoinTask需要通过ForkJoinPool才能执行。

4. 示例demo

需求：1+2+3+···+1000，分解为1+2+···500,501+502+···+1000，然后继续可以分解子任务

public class FockJoinTest extends RecursiveTask<Long>{

	private final int DEFAULT_CAPACITY = 100;
	
	private int start ;
	
	private int end ;
	
	public FockJoinTest(int start,int end){
		this.start= start;
		this.end = end;
	}

	@Override
	protected Long compute() {
		long sum  = 0;
		
		if(end - start < DEFAULT_CAPACITY){
			for(int i=start ;i<end;i++){
				sum += i;
			}
		}else{
			int middle = (start+end)/2;
			
			FockJoinTest fockJoinTest1 = new FockJoinTest(start,middle);
			FockJoinTest fockJoinTest2 = new FockJoinTest(middle,end);
			
			fockJoinTest1.fork();
			fockJoinTest2.fork();
			
			sum = fockJoinTest1.join() + fockJoinTest2.join();
		}
		return sum;
	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ForkJoinPool forkJoinPool = new ForkJoinPool();
		FockJoinTest fockJoinTest = new FockJoinTest(1,1000);
		
		long fockjoinStartTime = System.currentTimeMillis();
		long result = forkJoinPool.invoke(fockJoinTest);
		System.out.println(result);
		System.out.println("fock/join计算结果耗时"+(System.currentTimeMillis() - fockjoinStartTime));
	}
}