1.为什么要使用线程池

直接创建线程，线程本身需要占用内存空间，大量的线程会抢占宝贵的内存资源，如果处理不当，会导致内存溢出，而且，线程回收会给GC带来很大的压力，延迟GC的停顿时间。

2.常用线程池

<1>newFixedThreadPool
返回一个固定线程数量的线程池
<2>newSingleThreadExecutor()
返回一个只有一个线程的线程池
<3>newCachedThreadPool()
返回一个根据实际情况调整数量的线程池，线程池数量不确定，有空闲线程可以复用则复用，没有就一直会创建新的
<4>newSingleThreadScheduledExecutor()
返回一个计划任务线程池，但是线程数量为1
<5>newScheduledThreadPool()
返回一个计划任务线程池

2.1计划任务

计划任务不一定会立即安排执行任务，会在指定时间内进行调度。
3个重要的方法：
<1>schedule
会在给定的时间内，对任务进行一次调度
<2>scheduleAtFirstRate
会对任务进行周期性调度，周期为上一个任务开始执行的时间+周期时间=下一个任务的开始时间
<3>scheduleWithFixedDelay()
会对任务进行周期性调度，周期为上一个任务结束时间+周期时间=下一个任务的开始时间

任务堆叠处理：
ScheduleExecutorService不会让任务出现堆叠的情况，比如任务周期为2s,但是任务执行花了8秒，上一个任务没有执行完成，下一个任务不会开始执行，造成任务堆叠；但是这里上一任务执行完成后，下一个任务会马上执行。

注意：调度程度并不保证任务会无限期的持续调用，如果任务本身出现异常，那么后续的所有执行都会被中断，因此需要对异常处理。

3.核心线程池的内部实现

线程池核心类

ThreadPoolExecutor(int corePoolSize,
     int maxinumPoolSize, 
    long keepAliveTime,
    TimeUnit unit,
    BlockingQueue<Runnable> workQueue,
    ThreadFactory threadFactory
    RejectedExecutionHandler handler);

核心参数：

workQueue:

<1>直接提交的队列：SynchronousQueue
它没有容量，每一个插入操作都要等待一个相应的删除操作，每一个删除操作都要等待对应的插入操作。
如果没有空闲线程，则尝试创建新的线程，如果线程数量达到最大值，则使用拒绝策略；
<2>有界的任务队列：ArrayBlockingQueue
如果线程数量小于corePoolSize时，会优先创建新线程，若大于corePoolSize,则会将新任务加入到等待队列；等待队列已满，则在总线程数不大于maxinumPoolSize的前提下，创建新的线程执行任务，若大于，则执行拒绝策略；

<3>无界任务队列 LinkedBlockQueue
除非系统资源耗尽，否则无界的任务队列不存在任务入队列失败的情况；新任务到来时，如果线程数小于corePoolSize, 则创建新的线程执行任务，但当线程池中线程达到poolSize后，就不会增加；

<4>优先任务队列： PriorityBlockingQueue
可以控制任务执行的先后顺序，它是一个特殊的无界队列

拒绝策略

AbortPolicy策略：直接抛出异常，阻止系统正常运行；
CallerRunsPolicy策略：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务，显然这样做不会真的丢弃任务，但是，任务提交线程池的性能极有可能会急剧下降；
DiscardOledestPolicy策略：丢弃最老的一个请求，也就是即将被执行的下一个，并尝试再次提交当前任务；
DiscardPolicy策略：丢弃无法处理的任务，不处理；

自定义拒绝策略：实现RejectExecutionHandler接口

自定义线程池

ThreadFactory是一个接口，只有一个方法

Thread newThread(Runnable r);

4.扩展线程池

ThreadPoolExecutor提供beforeExecutor、afterExecutor和terminated() 三个方法对线程池进行控制。

ThreadPoolExecutor.Worker是ThreadPoolExecutor的内部类，实现了Runnable接口，执行Worker.runTask()方法内部，执行了
beforeExecutor和afterExecute方法

terminated记录了整个线程池的退出

5.优化线程数量

经验公式
Ncpu -> CPU数量
Ucpu -> 目标cpu的使用率
W/C -> 等待时间与计算时间的比率

最优线程池大小=Ncpu * Ucpu * (1 + W/C)

6.在线程池中寻找堆栈

自定义ThreadPoolExecutor 包装submit方法

    public static class TraceThreadPoolExecutor extends ThreadPoolExecutor {

        public TraceThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                                       long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
            super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
        }

        @Override
        public Future<?> submit(Runnable task) {
            return super.submit(wrap(task, clientTrace()));
        }

        private Throwable clientTrace() {
            return new Throwable("trace");
        }

        private Runnable wrap(final Runnable task, final Throwable clientTrace) {
            return new Runnable() {
                @Override
                public void run() {
                    try {
                        task.run();
                    } catch (Throwable e) {
                        e.printStackTrace();
                        throw e;
                    }
                }
            };
        }
    }

    public static void main(String[] args) {
        TraceThreadPoolExecutor executor = new TraceThreadPoolExecutor(2,4, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        for (int i = 0; i < 5; i ++) {
            executor.submit(new MyTask(i));
        }
        executor.shutdown();
    }

    public static class MyTask implements Runnable {

        private int size;

        public MyTask(int size) {
            this.size = size;
        }

        @Override
        public void run() {
            int result = 100/size;
            System.out.println(result);
        }
    }

7.fork/join框架

含义：
fork() 创建子进程，使得系统进程可以多一个执行分支；
join() 等待，等待这个执行分支执行完毕，才能得到结果

ForkJoinPool中如果A线程执行完毕，线程A会帮助线程B，从线程B的任务队列中拿一个任务过来处理，尽可能达到平衡；

注意：线程执行自己的任务从任务队列顶部拿任务，而帮助别人执行时，从队列底部拿任务，可以有效避免数据竞争；

ForkJoinPoll的重要方法：

public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task);

向ForkJoinPool线程池提交一个ForkJoinTask任务，所谓的ForkJoinTask就是支持fork分解和join等待的任务。

ForkJoinTask有2个重要的子类：RecursiveAction和RecursiveTask. 他们分别代表没有返回值的任务和可以带返回值的任务。

【2019-06-23】线程池