Java架构师之线程（三）线程的并发工具类

## 1. Fork/Join框架
### 1.什么是分而治之？
规模为N的问题，N<阈值，直接解决，N>阈值，将N分解为K个小规模子问题，子问题互相对立，与原问题形式相同，将子问题的解合并得到原问题的解

<br/>
<br/>
### 1.2 Fork/Join使用的标准范式

>MyTask类需要继承RecursiveTask/RecursiveAction
其中RecursiveTask类的compute方法需要返回值 而RecursiveAction中的compute方法不需要返回值

#### 1.2.1 Fork/Join的同步用法同时演示返回结果值：统计整型数组中所有元素的和。
<br/>

生成指定长度随机数组的工具类
```java
public class MakeArray {
    //数组长度
    public static final int ARRAY_LENGTH  = 1000;

    public static int[] makeArray() {

        //new一个随机数发生器
        Random r = new Random();
        int[] result = new int[ARRAY_LENGTH];
        for(int i=0;i<ARRAY_LENGTH;i++){
            //用随机数填充数组
            result[i] =  r.nextInt(ARRAY_LENGTH*3);
        }
        return result;

    }
}
```
<br/>
<br/>

```java
public class SumArray {
    private static class SumTask extends RecursiveTask<Integer>{

        //定义阈值为数组长度的1/10
        private final static int THRESHOLD = MakeArray.ARRAY_LENGTH / 10;

        private int[] src;//需要进行计算的数组

        private int fromIndex;//开始计算的下标

        private int endIndex;//结束计算的下标

        public SumTask(int[] src, int fromIndex, int toIndex) {
            this.src = src;
            this.fromIndex = fromIndex;
            this.endIndex = toIndex;
        }

        @Override
        protected Integer compute() {
           //如果数组的长度小于阈值则计算
           if (endIndex - fromIndex < THRESHOLD){
               int count = 0;
               for(int i = fromIndex; i <= endIndex; i++){
                   SleepTools.ms(1);
                   count = count + src[i];
               }
               return count;
           }else{
               //如果数组的长度大于阈值则继续拆分数组 这里从中间将数组拆分为左右两个部分
               int mid = (fromIndex + endIndex) / 2;
               //将任务拆分为左右两个部分
               SumTask left = new SumTask(src, fromIndex, mid);
               SumTask right = new SumTask(src, mid + 1, endIndex);
               //执行所有的任务
               invokeAll(left, right);
               //将所有任务的结果聚合在一起
               return left.join() + right.join();
           }
        }
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        int[] src = MakeArray.makeArray();
        SumTask innerFind = new SumTask(src, 0, src.length - 1);
        long start = System.currentTimeMillis();
        forkJoinPool.invoke(innerFind);//同步调用
        System.out.println("Task is Running.....");
        System.out.println("The count is " + innerFind.join()
                +" spend time:"+ (System.currentTimeMillis() -start) + "ms");
    }
}
```