thread53

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();    }}