thread53 - ForkJoinPool

package com.neutron.t23;

import java.io.IOException;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.*;

/**
 * 线程池
 *    1.固定个数的线程池
 *    2.缓存线程池，开始线程数0
 *         如果需要线程，当前线程池没有，那么创建线程池
 *         如果需要线程，线程池中有没有使用的线程，那么使用已经存在的线程
 *         如果线程池中线程超过60秒(默认)没有使用，那么该线程停止
 *    3.只有1个线程的线程池
 *         保证线程执行的先后顺序
 *    4.ScheduledPool
 *          和DelayedQueue类似,定时执行
 *    5.WorkStealingPool(任务窃取，都是守护线程)
 *          每个线程都有要处理的队列中的任务，如果其中的线程完成自己队列中的任务，
 *          那么它可以去其他线程中获取其他线程的任务去执行
 *          WorkStealingPool底层是ForkJoinPool
 *    6.ForkJoinPool
 *          使用场景最多的，各种语言都在用的
 *          ForkJoinPool必须执行的是ForkJoinTask
 *          常用RecursiveAction或者RecursiveTask的子类
 *              RecursiveAction没有返回值
 *              RecursiveTask有返回值
 */
public class T243ForkJoinPool {
    // 50w长度数组
    static final int[] nums = new int[500000];
    // 最小任务计算量
    static final int MAX_NUM = 10000;

    static Random r = new Random();

    static {
        for (int i = 0; i < nums.length; i++) {
            nums[i] = r.nextInt(100);
        }
        System.out.println("res1: "+ Arrays.stream(nums).summaryStatistics().getSum());
    }

    // 使用ForkJoinPool
    static class AddAct extends RecursiveAction {
        int start, end;

        AddAct(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected void compute() {
            if (this.end - this.start <= MAX_NUM) {
                System.out.println("start:" + start + " end:" + end);
                long sum = 0;
                for (int i = start; i < end; i++) {
                    sum += nums[i];
                }
                System.out.println("from " + start + " to " + end + " is: " + sum);
            } else {
                int middle = start + (end - start) / 2;
                AddAct sumTask1 = new AddAct(start, middle);
                AddAct sumTask2 = new AddAct(middle, end);
                sumTask1.fork();
                sumTask2.fork();
            }
        }
    }

    // 使用ForkJoinPool
    static class AddTask extends RecursiveTask<Long> {
        int start, end;

        AddTask(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute() {
            long sum = 0;
            if (this.end - this.start <= MAX_NUM) {
                for (int i = start; i < end; i++) {
                    sum += nums[i];
                }
                return sum;
            } else {
                /*
                 * note:
                 * int middle = start + (end - start) / 2;
                 * AddTask sumTask1 = new AddTask(start, middle);
                 * AddTask sumTask2 = new AddTask(middle, end);
                 * not and why ? :
                 * AddTask sumTask2 = new AddTask(middle + 1, end);
                 */
                int middle = start + (end - start) / 2;
                AddTask sumTask1 = new AddTask(start, middle);
                AddTask sumTask2 = new AddTask(middle, end);
                sumTask1.fork();
                sumTask2.fork();
                return sumTask1.join() + sumTask2.join();

                // wrong, why?
                /*int middle = (start + end) / 2;
                AddTask sumTask1 = new AddTask(start, middle);
                AddTask sumTask2 = new AddTask(middle + 1, end);
                sumTask1.fork();
                sumTask2.fork();
                return sumTask1.join() + sumTask2.join();*/
            }
        }
    }

    public static void main(String[] args) throws IOException {
        ForkJoinPool forkJoinPool = new ForkJoinPool();

        // 1.以下三行是Act的计算方式
        /*AddAct act = new AddAct(1, nums.length);
        forkJoinPool.execute(act);
        System.in.read();*/

        AddTask task = new AddTask(0, nums.length);
        forkJoinPool.execute(task);
        long result = task.join();
        System.out.println("res2: " + result);
        forkJoinPool.shutdown();
    }
}