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);