Fork/Join框架

           Doug Lea教授写了一个并行处理的框架，最近偶然看见他的论文。拜读了一下感觉很好。这个框架佳作Fork/Join框架，顾名思义就是先进行fork再join组合结果的意思。下面是这篇论文的地址，英文好的同志可以好好看一下：http://gee.cs.oswego.edu/dl/papers/fj.pdf

           如果觉得英文论文有点难懂，我按照我自己的理解写在下面帮助大家理解一下：

      首先，关于Fork/Join的大篇幅的介绍就不在这里写了，大家可以百度了解一下。我主要介绍一下用法。

      分治的思想在我们计算机圈是很有名的，分治分治，分而治之。这个Fork/Join有点并行分治的意思。

      要想使用这个框架必须继承RecursiveTask<T>或者RecursiveAction<T>,我从两个例子解释一下这两个的不同。

 

问题1：高斯定理可以很快的计算等差序列的加法，我们就用Fork/Join框架实现一下等差序列的加法：

 

package com.wjy.enumstudy;

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

public  class PlusPlus extends RecursiveTask<Integer>{
	private static final int THRESHOLE=100;
	private int start;
	private int end;
	public PlusPlus(int start,int end){
		this.start=start;
		this.end=end;
	}
	
	@Override
	protected Integer compute() {
		// TODO Auto-generated method stub
		int sum=0;
		if(end-start<THRESHOLE){
			for(int i=start;i<=end;i++){
				sum+=i;
			}
		}else{
			int middle=(start+end)/2;
			PlusPlus left=new PlusPlus(start, middle);
			PlusPlus right=new PlusPlus(middle+1, end);
			
			left.fork();
			right.fork();
			sum=left.join()+right.join();
		}
		return sum;
	}
	
	public static void main(String args[]) throws InterruptedException, ExecutionException{
		ForkJoinPool pool=new ForkJoinPool();
		Future<Integer> result=pool.submit(new PlusPlus(1, 10000));
		System.out.println(result.get());
		System.err.println(10001*5000);
	}
	
}

 算法很简单，在100个数以内的我们直接迭代计算和值。否则采用Fork/Join框架分治计算。

 

注：System.err.println(10001*5000);是高斯定理计算的答案。做对比用。

运行结果：

 

50005000

50005000

 

通过上面的例子可以看出来RecursiveTask是有返回值的。而RecursiveAction是没有的，比如说排序就不需要有返回值。所以第二个例子就是排序，使用RecursiveAction。

 

问题2：给数组排序：

package com.wjy.enumstudy;

import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.TimeUnit;

public  class SortSort extends RecursiveAction{
	private static final int THRESHOLE=10;
	private int[] array;
	private int start;
	private int end;
	public SortSort(int[] array,int start,int end){
		this.array=array;
		this.start=start;
		this.end=end;
	}
	private void sampleSort(int[] array,int start,int end){
		Arrays.sort(array, start, end+1);  //看这里toIndex是end+1!!!
	}
	private void swap(int[] array,int numA,int numB){
		array[numA]=array[numA]+array[numB];
		array[numB]=array[numA]-array[numB];
		array[numA]=array[numA]-array[numB];
	}
	/**
	 * 像快排一样每次保证最后一个数处在最终的正确位置上
	 * 比他小的在他左边，比他大的在他右边
	 * @param array
	 * @param start
	 * @param end
	 * @return
	 */
	private int partion(int[] array,int start,int end){
		int small=start;
		int count=0;
		int value=array[end];
		int length=end-start+1;
		for(int i=start;i<end;i++){
			if(array[i]<value){
				if(i!=small)
				{
					swap(array, i, small);
				}
				small++;
				count++;
			}
		}
		if((start+count)!=end){
			swap(array, start+count, end);
		}
		
		return start+count;
	}
	@Override
	protected void compute() {
		// TODO Auto-generated method stub
		if(end-start<THRESHOLE){
			sampleSort(array,start,end);
		}else{
			int tag=partion(array,start,end);
			new SortSort(array, start, tag-1).fork();
			new SortSort(array, tag+1, end).fork();
		}
	}
	
	
	public static void main(String args[]) throws InterruptedException, ExecutionException{
		int array[]={3,7,2,1,5,4,3,8,9,4,6};
		ForkJoinPool pool=new ForkJoinPool();
		pool.submit(new SortSort(array,0,array.length-1));
		pool.shutdown();
		pool.awaitTermination(1000, TimeUnit.SECONDS);
		
		System.out.println(Arrays.toString(array));
	}



}

 运行结果：

[1, 2, 3, 3, 4, 4, 5, 6, 7, 8, 9]

 

对于Arrays.sort(array,fromIndex,toIndex);这个函数，其中的toIndex要给的比预想的大一。举个例子：

对于int[] array={3,2,1};

要是Arrays.sort(array,0,2);的话运行结果是{2,3,1}。

所以必须是Arrays.sort(array,0,3);