ThreadPool笔记

线程池的优势：
线程池做的工作只要是控制运行线程数量，处理过程是将任务放在队列中，然后线程创建后启动这些任务，如果线程数量超过了最大数量，超出数量线程派对等候，
等待其它线程执行完毕，再从队列中取出任务执行。
它的主要特点：线程复用；控制最大并发数；管理线程。
一、降低资源消耗，复用线程，降低线程创建与销毁。
二、提高响应速度，当任务到达时，任务不需要等待线程创建直接执行。
三、提高线程可管理性，线程是稀缺资源如果无限制创建，将会消耗系统cpu资源，使用线程池可以进一步管理、分配资源。
Executor
-
ExecutorService
-
AbstractExecutorService 、ScheduledExecutorService
-
ThreadPoolExecutor、ForkJoinPool
-
ScheduledThreadPoolExecutor
//corePoolSize=maximumPoolSize
ExecutorService executorService = Executors.newFixedThreadPool(5); //一池5线程
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
//corePoolSize=maximumPoolSize=1
ExecutorService executorService = Executors.newSingleThreadExecutor(); //一池1线程
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
//corePoolSize=0,maximumPoolSize=Integer.MAX_VALUE
ExecutorService executorService = Executors.newCachedThreadPool(); //一池N线程，可扩容
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }
线程池核心参数：
1、corePoolSize：线程池常驻核心线程数。
2、maximumPoolSize：线程池中能够容纳同时执行最大线程数，此值必须大于等于1。
3、keepAliveTime：多余线程存活时间，当线程池中线程数大于corePoolSize，当空闲时间到达keepAliveTime，多余线程会被销毁，直到线程数为corePoolSize为止。
4、unit：keepAliveTime单位。
5、workQueue：任务队列，被提交且尚未执行任务。
6、ThreadFactory：表示生成线程池中工作线程的工厂。
7、RejectedExecutionHandler：拒绝策略，表示当任务队列已满，并且工作线程大于线程池最大线程数时，若有任务提交，拒绝策略。
线程池工作流程：
1、当创建线程池后，开始等待请求
2、当调用了execute方法添加一个请求，线程池会做如下判断
    1）如果正在运行线程数小于corePoolSize线程数，会马上创建线程运行这个任务；
    2）如果正在运行线程数大于或等于corePoolSize线程数，会立刻把该任务放入阻塞队列；
    3）如果阻塞队列已满且正在运行线程小于maximumPoolSize线程数，则会创建新的线程；
    4）如果阻塞队列已满且运行线程等于或大于maximumPoolSize线程数，则会执行拒绝策略；
3、当一个任务完成时，它会从阻塞队列取下一个任务来执行；
4、当一个线程无事可做，并且大于corePoolSize线程数时，该线程会被回收；当整个线程池所有线程处于空闲时，线程数应该等于核心线程数；
线程池参数如何设置：
阿里开发手册不允许使用Executors创建线程池，而是通过ThreadPoolExecutor方式
Executors.newCachedThreadPool() 最大线程数：Integer.MAX_VALUE，会创建大量线程导致OOM
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                2,
                5,
                2000,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardPolicy());
拒绝策略（默认AbortPolicy）
new ThreadPoolExecutor.AbortPolicy() 抛异常
new ThreadPoolExecutor.CallerRunsPolicy() 将任务回退给调用者
new ThreadPoolExecutor.DiscardOldestPolicy() 抛弃队列中等待最久的
new ThreadPoolExecutor.DiscardPolicy() 丢弃无法处理任务，如果任务允许丢弃这是个最好的

线程池工作流程