ForkJoin分而治之

这里的实现方式用了java8之前的，比较易于阅读代码，java8版本对于异步编程来说添加一些异步编程的语法糖和lambda表达式，

还有一些stream式数据处理，并行流的使用。

分治不属于设计模式，应该归类于算法，但是对我来说，它就是一种实现编程模型，理解并发并行可以从这个小小的框架入手。

学习要点

1.分而治之的思想

2.当把任务拆分之后，如果需要拿到任务执行的返回结果 forkJoin.get() ，如果数据量比较大的话，get还是很慢的，它总是要一个一个地把每个结果拿到之后再合并，除非不要返回结果，纯异步模式执行

总结一下： 把单线程任务->  给到多个线程 -> 最后再get合并多线程任务的返回结果。

 


public class ForkJoinTest {

    private static double[] d;



    private static class ForkJoinTask extends RecursiveTask<Integer> {

        private int first;

        private int last;

        public ForkJoinTask(int first, int last) {

            this.first = first;

            this.last = last;

        }

        protected Integer compute() {

            int subCount;

            if (last - first < 10) {
//true 真正的执行，false 继续递归
                subCount = 0;

                for (int i = first; i <= last; i++) {

                    if (d[i] > 0.5)

                        subCount++;

                }

            }

            else {

                int mid = (first + last) >>> 1;

                ForkJoinTask left = new ForkJoinTask(first, mid);

                left.fork();

                ForkJoinTask right = new ForkJoinTask(mid + 1, last);

                right.fork();

                subCount = left.join();

                subCount += right.join();

            }

            return subCount;

        }


    }

    public static  void main(String[] args) {

        d = new ForkJoinTest().createArrayOfRandomDoubles();

        int n = new ForkJoinPool().invoke(new ForkJoinTask(0, 9999999));

        System.out.println("Found " + n + " values");

    }


    public  double[] createArrayOfRandomDoubles() {

        double[] doubles = new double[100];

        for(int i =0;i<100;i++){

            Random random = new Random();

            double d = random.nextDouble() * 10;

            doubles[i]=d;

        }


        return doubles;

    }



}