并发(四):线程池ThredPool

为什么要使用线程池：

1. 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗.
2. 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性。线程是稀缺资源如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。

---

线程池实现原理：

当线程池执行execute()方法，线程池的处理流程如下：

 1. 线程池判断核心线程池里的线程是否都在执行任务corePoolSize=0?。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则2。
 2. 线程池判断工作队列是否已满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了,则进入3。(如果阻塞队列是无界的比如LinkedTransferQueue，那么核心线程池以外的线程是不起作用的)。
 3. 线程池判断线程池的线程是否都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。如果已经满了线程数量达到maximumPoolSize，则交给饱和策略来处理这个任务。
 (饱和策略：threadPoolExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
DiscardOldestPolicy:丢弃队列里最近的一个任务，并执行当前任务。
DiscardPolicy:不处理，丢弃掉。
AbortPolicy：直接抛出异常。(默认)
CallerRunsPolicy：只用调用者所在线程来运行任务。
)

---

各种线程池:
ThreadPoolExecutor通常使用工厂类Executors来创建。包括：FixedThreadPool、SingleThreadExecutor、CachedThreadPool。不管创建那一中线程池，实际还是调用的这个构造函数。只是针对不同的场景来设置corePoolSize大小和BlockingQueue的类型。

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)

Java里的阻塞队列：

 - ArrayBlockingQueue:数组组成的有界阻塞队列。
 - LinkedBlockingQueue:链表组成的有界阻塞队列。最大Interger_max.
 - LinkedTransferQueue:链表组成的无界阻塞队列。
 - LinkedBlockingDeque：链表组成的双向阻塞队列。
 - PriorityBlockingQueue:支持优先级排序的无界阻塞队列。
 - DelayQueue:使用优先级队列实现的无界阻塞队列。(定时任务调度)
 - SynchronousQueue:不存储元素的阻塞队列。

为什么是阻塞队列而不是等待队列，因为底层使用lock.newCondition();创建监视器，通过singnal,await方法来维持两个阻塞线程队列。

    public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

CachedThreadPool:大小无界的线程池，适用于执行很多短期异步任务的程序，或者是负载较轻的服务器。

 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
        new SynchronousQueue<Runnable>());
    }

CachedThreadPool使用的是SynchronousQueue阻塞队列，当执行execute()方法时，执行流程(生产者消费者模式)：

 1. 首先执行SynchronousQueue.offer()。如果当前maximumPool中有空闲线程正在执行SynchronousQueue.poll()那么主线程执行offer操作与空闲线程执行的poll操作配对成功，主线程把任务交给空闲线程执行，execute()方法执行完成;否则执行2。
 2. 当初始maximumPool为空，或者maximumPool中当前没有空闲线程时，将没有线程执行SynchronousQueue.poll()。这种情况下CachedThreadPool会创建一个新线程执行任务，execute()方法执行完成。
 3. 2中新创建的线程将任务执行完后，会执行SynchronousQueue.poll()。这个poll操作会让空闲线程最多在SynchronousQueue中等待60秒钟。如果60秒钟内主线程提交了一个新任务（1步骤），那么这个空闲线程将执行主线程提交的新任务；否则,这个空闲线程将终止。

SynchronousQueue公平队列使用了队列数据结构，非公平队列使用了栈数据结构。参考：

SynchronousQueue实现原理：https://zhuanlan.zhihu.com/p/29227508

---