Java 7 Fork/Join 并行计算框架概览

Fork/Join框架

    依靠应用程序本身并行拆封任务，如果使用简单的多线程程序的方法，复杂度必然很大。这就需要一个更好的范式或者工具来代程序员处理这类问题。Java 7也意识到了这个问题，才标准库中集成了由Doug Lea开发的Fork/Join并行计算框架。通过使用 Fork/Join 模式，软件开发人员能够方便地利用多核平台的计算能力。尽管还没有做到对软件开发人员完全透明，Fork/Join 模式已经极大地简化了编写并发程序的琐碎工作。对于符合 Fork/Join 模式的应用，软件开发人员不再需要处理各种并行相关事务，例如同步、通信等，以难以调试而闻名的死锁和 data race 等错误也就不会出现，提升了思考问题的层次。你可以把 Fork/Join 模式看作并行版本的 Divide and Conquer 策略，仅仅关注如何划分任务和组合中间结果，将剩下的事情丢给 Fork/Join 框架。但是Fork/Join并行计算框架，并不是银弹，并不能解决所有应用程序在超多核心处理器上的并发问题。

    如果一个应用能被分解成多个子任务，并且组合多个子任务的结果就能够获得最终的答案，那么这个应用就适合用 Fork/Join 模式来解决。其原理如下图。

    应用程序开发者需要做的就是拆分任务并组合每个子任务的中间结果，而不用再考虑线程和锁的问题。

一个简单的例子

我们首先看一个简单的Fork/Join的任务定义。

Java代码  

1. public class Calculator extends RecursiveTask<Integer> {  
2.   
3.     private static final int THRESHOLD = 100;  
4.     private int start;  
5.     private int end;  
6.   
7.     public Calculator(int start, int end) {  
8.         this.start = start;  
9.         this.end = end;  
10.     }  
11.   
12.     @Override  
13.     protected Integer compute() {  
14.         int sum = 0;  
15.         if((start - end) < THRESHOLD){  
16.             for(int i = start; i< end;i++){  
17.                 sum += i;  
18.             }  
19.         }else{  
20.             int middle = (start + end) /2;  
21.             Calculator left = new Calculator(start, middle);  
22.             Calculator right = new Calculator(middle + 1, end);  
23.             left.fork();  
24.             right.fork();  
25.   
26.             sum = left.join() + right.join();  
27.         }  
28.         return sum;  
29.     }  
30.   
31. }  

 

    这段代码中，定义了一个累加的任务，在compute方法中，判断当前的计算范围是否小于一个值，如果是则计算，如果没有，就把任务拆分为连个子任务，并合并连个子任务的中间结果。程序递归的完成了任务拆分和计算。

    任务定义之后就是执行任务，Fork/Join提供一个和Executor框架的扩展线程池来执行任务。

Java代码  

1. @Test  
2. public void run() throws Exception{  
3.     ForkJoinPool forkJoinPool = new ForkJoinPool();  
4.     Future<Integer> result = forkJoinPool.submit(new Calculator(0, 10000));  
5.   
6.     assertEquals(new Integer(49995000), result.get());  
7. }  

 

Fork/Join框架的主要类

RecursiveAction供不需要返回值的任务继续。

RecursiveTask通过泛型参数设置计算的返回值类型。

ForkJoinPool提供了一系列的submit方法，计算任务。ForkJoinPool默认的线程数通过Runtime.availableProcessors()获得，因为在计算密集型的任务中，获得多于处理性核心数的线程并不能获得更多性能提升。

public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task) {
    doSubmit(task);
    return task;
}

sumit方法返回了task本身，ForkJoinTask实现了Future接口，所以可以通过它等待获得结果。

另一例子

这个例子并行排序数组，不需要返回结果，所以继承了RecursiveAction。

Java代码  

1. public class SortTask extends RecursiveAction {  
2.     final long[] array;  
3.     final int start;  
4.     final int end;  
5.     private int THRESHOLD = 100; //For demo only  
6.   
7.     public SortTask(long[] array) {  
8.         this.array = array;  
9.         this.start = 0;  
10.         this.end = array.length - 1;  
11.     }  
12.   
13.     public SortTask(long[] array, int start, int end) {  
14.         this.array = array;  
15.         this.start = start;  
16.         this.end = end;  
17.     }  
18.   
19.     protected void compute() {  
20.         if (end - start < THRESHOLD)  
21.             sequentiallySort(array, start, end);  
22.         else {  
23.             int pivot = partition(array, start, end);  
24.             new SortTask(array, start, pivot - 1).fork();  
25.             new SortTask(array, pivot + 1, end).fork();  
26.         }  
27.     }  
28.   
29.     private int partition(long[] array, int start, int end) {  
30.         long x = array[end];  
31.         int i = start - 1;  
32.         for (int j = start; j < end; j++) {  
33.             if (array[j] <= x) {  
34.                 i++;  
35.                 swap(array, i, j);  
36.             }  
37.         }  
38.         swap(array, i + 1, end);  
39.         return i + 1;  
40.     }  
41.   
42.     private void swap(long[] array, int i, int j) {  
43.         if (i != j) {  
44.             long temp = array[i];  
45.             array[i] = array[j];  
46.             array[j] = temp;  
47.         }  
48.     }  
49.   
50.     private void sequentiallySort(long[] array, int lo, int hi) {  
51.         Arrays.sort(array, lo, hi + 1);  
52.     }  
53. }  

 

Java代码  

1. @Test  
2. public void run() throws InterruptedException {  
3.     ForkJoinPool forkJoinPool = new ForkJoinPool();  
4.     Random rnd = new Random();  
5.     long[] array = new long[SIZE];  
6.     for (int i = 0; i < SIZE; i++) {  
7.         array[i] = rnd.nextInt();  
8.     }  
9.     forkJoinPool.submit(new SortTask(array));  
10.   
11.     forkJoinPool.shutdown();  
12.     forkJoinPool.awaitTermination(1000, TimeUnit.SECONDS);  
13.   
14.     for (int i = 1; i < SIZE; i++) {  
15.         assertTrue(array[i - 1] < array[i]);  
16.     }  
17. }