重作一道Java面試題（Fork/Join）

前幾天參加了一場面試，當時有這莫一道題：

如何充分利用多核CPU，計算很大List中全部整數的和？
複製代碼

老實說，我當時並無想出來具體該如何實現，只是有個大體的方向，確定是分治法的思想；這兩天我一直在嘗試將這些當時沒作出來的題想辦法作出來，查了一些資料，看了若干文章，如今反過頭來再來嘗試解決一下這個題吧。

通過這兩天的學習，我基本上搜集到了兩種解這道題的思路： 1.用CyclicBarrier 這種方法，有網友給出了詳盡的解釋，在此再也不復述。

2.用Fork/Join 這個方法我是受到了這幾篇文章的啓發：

• JDK 7 中的 Fork/Join 模式

• 個人Java開發學習之旅------>Java使用Fork/Join框架來並行執行任務

• Java 多線程（5）：Fork/Join 型線程池與 Work-Stealing 算法

具體的看代碼吧：

package com.github.since1986.test;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
import java.util.stream.IntStream;

/**
 * Created by since1986 on 2017/9/17.
 */
public class ForkJoinTest {

    public static void main(String... args) throws InterruptedException, ExecutionException {
        int[] array = IntStream.rangeClosed(0, 1_00_000_000).toArray(); //模擬一個「很大」的List，這裏用直接用數組代替了（題目裏其實也沒說明白「很大」究竟是什麼概念，實際上太大了會OOM，但我以爲這道題主要考查的是對併發編程的基本思路吧，應該不會考察太深的，因此不用在乎了，要是確實是要把怎麼樣避免OOM也考慮到的話暫時還沒想到應該怎樣解決）

        //簡單粗暴的作法
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println(sum);

        //Fork/Join的作法
        ForkJoinPool forkJoinPool = new ForkJoinPool(); //起一個數量等於可用CPU核數的池子（對應題目中「充分利用多核」）
        Task task = new Task(0, array.length, 10_000, array);

        Future<Integer> future = forkJoinPool.submit(task); //提交Task
        System.out.println(future.get()); //得到返回值

        forkJoinPool.shutdown(); //關閉池子
    }

    static class Task extends RecursiveTask<Integer> {

        public static final int DEFAULT_THRESHOLD = 1000;
        private int high, low;
        private int threshold;
        private int[] array;

        Task(int low, int high, int threshold, int[] array) {
            this.array = array;
            this.low = low;
            this.high = high;
            this.threshold = threshold; //任務劃分的最小值（若爲1000則含義是Fork到1000大小時就再也不繼續Fork了）
        }

        @Override
        protected Integer compute() {
            //System.out.println("low: " + low + " high: " + high);
            if (high - low <= threshold) { //到了不能再Fork的閾值後直接循環累加返回
                int sum = 0;
                for (int i = low; i < high; i++) {
                    sum += array[i];
                }
                //System.out.println("sum: " + sum);
                return sum;
            } else { //沒有到閾值的話，繼續遞歸拆分任務爲左任務和右任務（分治法的思想）
                int middle = (high - low) / 2 + low;
                //System.out.println("middle: " + middle);
                Task leftHandTask = new Task(low, middle, threshold, array); //左任務
                Task rightHandTask = new Task(middle, high, threshold, array); //右任務
                leftHandTask.fork(); //左任務還要繼續拆，直到知足上邊if裏的閾值條件
                rightHandTask.fork(); //右任務也要繼續拆，直到知足上邊if裏的閾值條件
                return leftHandTask.join() + rightHandTask.join(); //最後Join獲得結果
            }
        }
    }
}
複製代碼