并发编程（十二）ForkJoin框架使用

public class LongSum extends RecursiveTask<Long> {
    static final int SEQUENTIAL_THRESHOLD = 1000;
    int low;
    int high;
    int[] array;
    LongSum(int[] arr, int lo, int hi) {
        array = arr;
        low = lo;
        high = hi;
    }
    /**
     * fork()方法：将任务放入队列并安排异步执行，一个任务应该只调用一次fork()函数，除非已经执行完毕并重新初始化。
     * tryUnfork()方法：尝试把任务从队列中拿出单独处理，但不一定成功。
     * join()方法：等待计算完成并返回计算结果。
     * isCompletedAbnormally()方法：用于判断任务计算是否发生异常。
     */
    protected Long compute() {
        if (high - low <= SEQUENTIAL_THRESHOLD) {
            long sum = 0;
            for (int i = low; i < high; ++i) {
                sum += array[i];
            }
            return sum;
        } else {
            int mid = low + (high - low) / 2;
            LongSum left = new LongSum(array, low, mid);
            LongSum right = new LongSum(array, mid, high);
            left.fork();
            right.fork();
            long rightAns = right.join();
            long leftAns = left.join();
            return leftAns + rightAns;
        }
    }
}

public class LongSumMain {
  //获取逻辑处理器数量
  static final int NCPU = Runtime.getRuntime().availableProcessors();
  public static void main(String[] args) throws Exception {
    long start = System.currentTimeMillis();
    int[] array = new int[20000000];
    Random random = new Random();
    for (int i = 0; i < 20000000; i++) {
      array[i] = random.nextInt(100);
    }
    //采用fork/join方式将数组求和任务进行拆分执行，最后合并结果
    LongSum longSum = new LongSum(array, 0, array.length);
      ForkJoinPool forkJoinPool  = new ForkJoinPool(NCPU); //使用的线程数
    ForkJoinTask<Long> task = forkJoinPool.submit(longSum);
    System.out.println("forkjoin sum=" + task.get());
    if(task.isCompletedAbnormally()){
      System.out.println(task.getException().toString());
    }
    forkJoinPool.shutdown();
  }
}