Java 7：Fork / Join框架示例

Java 7中的Fork / Join Framework专为可分解为较小任务的工作而设计，并将这些任务的结果组合起来以产生最终结果。 通常，使用Fork / Join Framework的类遵循以下简单算法：

// pseudocode
Result solve(Problem problem) {
  if (problem.size < SEQUENTIAL_THRESHOLD)
    return solveSequentially(problem);
  else {
    Result left, right;
    INVOKE-IN-PARALLEL {
      left = solve(extractLeftHalf(problem));
      right = solve(extractRightHalf(problem));
    }
    return combine(left, right);
  }
}

为了证明这一点，我创建了一个示例，使用fork / join从一个大型数组中查找最大数量：

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

public class MaximumFinder extends RecursiveTask<Integer> {

  private static final int SEQUENTIAL_THRESHOLD = 5;

  private final int[] data;
  private final int start;
  private final int end;

  public MaximumFinder(int[] data, int start, int end) {
    this.data = data;
    this.start = start;
    this.end = end;
  }

  public MaximumFinder(int[] data) {
    this(data, 0, data.length);
  }

  @Override
  protected Integer compute() {
    final int length = end - start;
    if (length < SEQUENTIAL_THRESHOLD) {
      return computeDirectly();
    }
    final int split = length / 2;
    final MaximumFinder left = new MaximumFinder(data, start, start + split);
    left.fork();
    final MaximumFinder right = new MaximumFinder(data, start + split, end);
    return Math.max(right.compute(), left.join());
  }

  private Integer computeDirectly() {
    System.out.println(Thread.currentThread() + ' computing: ' + start
                       + ' to ' + end);
    int max = Integer.MIN_VALUE;
    for (int i = start; i < end; i++) {
      if (data[i] > max) {
        max = data[i];
      }
    }
    return max;
  }

  public static void main(String[] args) {
    // create a random data set
    final int[] data = new int[1000];
    final Random random = new Random();
    for (int i = 0; i < data.length; i++) {
      data[i] = random.nextInt(100);
    }

    // submit the task to the pool
    final ForkJoinPool pool = new ForkJoinPool(4);
    final MaximumFinder finder = new MaximumFinder(data);
    System.out.println(pool.invoke(finder));
  }
}

MaximumFinder类是RecursiveTask ，它负责从数组中查找最大数目。 如果数组的大小小于阈值（5），则通过遍历数组直接找到最大值。 否则，将数组分成两半，每半递归，然后等待它们完成（ join ）。 一旦我们得到了每一半的结果，我们就可以找到两个的最大值并返回。

参考： fahd.blog博客上的JCG合作伙伴 Fahd Shariff的Java 7：Fork / Join Framework示例 。

翻译自: https://www.javacodegeeks.com/2013/02/java-7-forkjoin-framework-example.html