fork/join 并行编程

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


public class MaxValue {
	
	private static final int RANGE_LENGTH = 200;
	private final ForkJoinPool forkJoinPool = new ForkJoinPool();
	private static class MaxValueTask extends RecursiveTask<Long>{
		private final long[] array;
		private final int start;
		private final int end;
		public MaxValueTask(long[] array,int start,int end) {
			// TODO Auto-generated constructor stub
			this.array=array;
			this.start=start;
			this.end=end;
		}
		@Override
		protected Long compute() {
			long max=Long.MIN_VALUE;
			if(end-start <= RANGE_LENGTH){
				for(int i=start;i<end;i++){
					if(array[i]>max){
						max=array[i];
					}
				}
			}else{
				int mid=(start+end)/2;
				MaxValueTask lowTask = new MaxValueTask(array,start,mid);
				MaxValueTask highTask = new MaxValueTask(array, mid, end);
				lowTask.fork();
				highTask.fork();
				max = Math.max(max, lowTask.join());
				max=Math.max(max, highTask.join());
			}
			return max;
		}
	}
	public void calculate(long[] array){
		MaxValueTask task = new MaxValueTask(array, 0, array.length);
		Long result = forkJoinPool.invoke(task);
		System.out.println(result);
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		long[] array ={2,3,5,44,1,4,5};
		new MaxValue().calculate(array);
	}

}

目的是为更好的利用底层平台上的多核CPU和多处理器来进行处理，解决问题通常使用分治（divide and conquer）算法或map/reduce算法的map 和reduce操作。

相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上。

    在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。

    在fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行，那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行（减少等待时间，提高性能）。 

注意：为使fork/join框架能高效运行，在每个子问题的实现中应该避免使用synchronized关键词或其他方式来进行同步，在不应该使用阻塞式I/O操作或过多地访问共享变量。

        理想情况下，每个子问题的实现都应该只进行CPU相关的计算，并且只使用每个问题的内部对象。唯一的同步应该只发生在子问题和创建他的问题之间。