【JDK7】新特性（5） fork/join 框架

    对于框架的原理，能够阅读 Doug Lea 的文章“A Java Fork/Join Framework”：了解 Fork/Join 模式的实现机制和执行性能。
    原理解析：fork分解，join结合。这个框架的本质是将一个任务分解成多个子任务，每一个子任务用单独的线程去处理。这里用到了递归的思想。框架的结构图能够参考

 图片来源（http://www.ibm.com/developerworks/cn/java/j-lo-forkjoin/index.html）

    使用fork/join 框架很简单，
        1.实现子问题的通常求解算法
        2.如何分解问题
        3.继承 RecursiveAction ，实现compute()方法

Result solve(Problem problem) {  
if (problem is small)  
    directly solve problem  
else {  
    split problem into independent parts  
    fork new subtasks to solve each part  
    join all subtasks  
    compose result from subresults  
}

    这里我经过一个改进的二分查找来说解fork/join的使用。（后面才发现，选用这个案例是很是失败的，由于二分查找的时间是logn,而建立线程的开销更大，这样并不能体现多线程二分查找的优点，因此这个代码不具备实用性，只是为了说明如何使用框架：）
    代码以下：
BinarySearchProblem.java

package testjdk7;  
  
import java.util.Arrays;  
/** 
 * @author kencs@foxmail.com 
 */  
public class BinarySearchProblem {  
    private final int[] numbers;  
    private final int start;  
    private final int end;  
    public final int size;  
      
    public BinarySearchProblem(int[] numbers,int start,int end){  
        this.numbers = numbers;  
        this.start = start;  
        this.end = end;  
        this.size = end -start;  
    }  
      
    public int searchSequentially(int numberToSearch){  
       //偷懒，不本身写二分查找了  
       return Arrays.binarySearch(numbers, start, end, numberToSearch);  
    }  
      
    public BinarySearchProblem subProblem(int subStart,int subEnd){  
        return new BinarySearchProblem(numbers,start+subStart,start+subEnd);  
    }  
}

BiSearchWithForkJoin.java

package testjdk7;  
import java.util.concurrent.ForkJoinPool;  
import java.util.concurrent.RecursiveAction;  
  
/** 
 * @author kencs@foxmail.com 
 */  
public class BiSearchWithForkJoin extends RecursiveAction {  
    private final int threshold;  
    private final BinarySearchProblem problem;  
    public int result;  
    private final int numberToSearch;  
      
    public BiSearchWithForkJoin(BinarySearchProblem problem,int threshold,int numberToSearch){  
        this.problem = problem;  
        this.threshold = threshold;  
        this.numberToSearch = numberToSearch;  
    }  
  
    @Override  
    protected void compute() {  
       if(problem.size < threshold){ //小于阀值，就直接用普通的二分查找  
           result = problem.searchSequentially(numberToSearch);  
       }else{  
           //分解子任务  
           int midPoint = problem.size/2;  
           BiSearchWithForkJoin left = new BiSearchWithForkJoin(problem.subProblem(0, midPoint),threshold,numberToSearch);  
           BiSearchWithForkJoin right = new BiSearchWithForkJoin(problem.subProblem(midPoint+1, problem.size),threshold,numberToSearch);  
           invokeAll(left,right);  
           result = Math.max(left.result, right.result);  
       }  
    }  
      
    //构造数据  
    private static final int[] data = new int[1000_0000];  
    static{  
        for(int i = 0;i<1000_0000;i++){  
            data[i] = i;  
        }  
    }  
    public static void main(String[] args){  
       BinarySearchProblem problem = new BinarySearchProblem(data,0,data.length);  
       int threshold = 100;  
       int nThreads = 10;  
       //查找100_0000所在的下标  
       BiSearchWithForkJoin  bswfj = new BiSearchWithForkJoin(problem,threshold,100_0000);  
       ForkJoinPool fjPool = new ForkJoinPool(nThreads);  
       fjPool.invoke(bswfj);  
       System.out.printf("Result is:%d%n",bswfj.result);  
    }  
      
      
}

RecursiveTask 还能够带返回值，这里给出一段代码做为参考（斐波那契函数）

（来自http://www.ibm.com/developerworks/cn/java/j-lo-forkjoin/index.html）

class Fibonacci extends RecursiveTask<Integer> {  
    final int n;  
  
    Fibonacci(int n) {  
        this.n = n;  
    }  
  
    private int compute(int small) {  
        final int[] results = { 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 };  
        return results[small];  
    }  
  
    public Integer compute() {  
        if (n <= 10) {  
            return compute(n);  
        }  
        Fibonacci f1 = new Fibonacci(n - 1);  
        Fibonacci f2 = new Fibonacci(n - 2);  
        System.out.println("fork new thread for " + (n - 1));  
        f1.fork();  
        System.out.println("fork new thread for " + (n - 2));  
        f2.fork();  
        return f1.join() + f2.join();  
    }  
}

    只要问题可以分解成相似子问题的，均可以使用这个框架。对于大批量的数据尤为合适

【JDK7】新特性（1）概述：http://my.oschina.net/zhengjian/blog/94467
【JDK7】新特性（2）语法：http://my.oschina.net/zhengjian/blog/94473
【JDK7】新特性（3）JDBC4.1：http://my.oschina.net/zhengjian/blog/95070
【JDK7】新特性（4）NIO2.0 文件系统：http://my.oschina.net/zhengjian/blog/95071
【JDK7】新特性（5）fork/join 框架：http://my.oschina.net/zhengjian/blog/95072
【JDK7】新特性（6）监听文件系统的更改：http://my.oschina.net/zhengjian/blog/95077
【JDK7】新特性（7）监听文件系统的更改：http://my.oschina.net/zhengjian/blog/95078
【JDK7】新特性（8）异步io/AIO：http://my.oschina.net/zhengjian/blog/95081

原文地址： http://janeky.iteye.com/blog/1047805