线程池原理

线程池的优点

1、线程是稀缺资源，使用线程池可以减少创建和销毁线程的次数，每个工作线程都可以重复使用。

2、可以根据系统的承受能力，调整线程池中工作线程的数量，防止因为消耗过多内存导致服务器崩溃。

线程池的创建

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

corePoolSize：线程池核心线程数量

maximumPoolSize:线程池最大线程数量

keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间

unit： 存活时间的单位

workQueue： 存放任务的队列

handler：超出线程范围和队列容量的任务的处理程序

线程池的实现原理

提交一个任务到线程池中，线程池的处理流程如下：

1、判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程。

2、线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程。

3、判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务。

任务被提交到线程池，会先判断当前线程数量是否小于corePoolSize，如果小于则创建线程来执行提交的任务，否则将任务放入workQueue队列，如果workQueue满了，则判断当前线程数量是否小于maximumPoolSize,如果小于则创建线程执行任务，否则就会调用handler，以表示线程池拒绝接收任务。
Java中线程池顶层接口是Executor，其中我们常用的实现类为ThreadPoolExecutor，其构造方法如下：

public ThreadPoolExecutor(int corePoolSize, //线程池中核心线程数的最大值
                          int maximumPoolSize,//线程池中能拥有最多线程数
                          long keepAliveTime,//表示空闲线程的存活时间。
                          TimeUnit unit,//表示keepAliveTime的单位。
                          BlockingQueue<Runnable> workQueue,//用于缓存任务的阻塞队列
                          ThreadFactory threadFactory,//
                          RejectedExecutionHandler handler//表示当workQueue已满，且池中的线程数达到maximumPoolSize时，线程池拒绝添加新任务时采取的策略。
                           ) {
                            this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
                            threadFactory, defaultHandler);
}

注意，线程池并没有标记哪个线程是核心线程，哪个是非核心线程，线程池只关心核心线程的数量。
线程池拒绝策略，handler一般可以采取以下四种取值。

BlockingQueue 阻塞队列，遵循FIFO，在任意时刻，不管并发有多高，永远只有一个线程能够进行队列的入队或者出队操作。是一个线程安全的队列。
队列分为：有界和无界

有界队列：队列满，只能进行出队操作，所有入队的操作必须等待，也就是被阻塞。
队列空，只能进行入队操作，所有出队的操作必须等待，也就是被阻塞。

workQueue：它决定了缓存任务的排队策略。对于不同的应用场景我们可能会采取不同的排队策略，这就需要不同类型的阻塞队列，在线程池中常用的阻塞队列有以下2种：

• SynchronousQueue：此队列中不缓存任何一个任务。向线程池提交任务时，如果没有空闲线程来运行任务，则入列操作会阻塞。当有线程来获取任务时，出列操作会唤醒执行入列操作的线程。从这个特性来看，SynchronousQueue是一个无界队列，因此当使用SynchronousQueue作为线程池的阻塞队列时，参数maximumPoolSizes没有任何作用。
• LinkedBlockingQueue：顾名思义是用链表实现的队列，可以是有界的，也可以是无界的，但在Executors中默认使用无界的。

线程池的五种状态

1.Running 能接受新任务以及处理已添加的任务。
2.Shutdown 不接受新任务，可以处理已经添加的任务。
3.Stop 不接受新任务，不处理已经添加的任务，并且中断正在处理的任务。
4.Tidying 所有的任务已经终止，ctl记录的"任务数量"为0，ctl负责记录线程池的运行状态与活动线程数量。
5.Terminated 线程池彻底终止，则线程池转变为terminated状态。

用一个原子类ctl来表示线程池生命状态。用于保证在高并发状态下，线程池的安全。

源码解析：

Executors中的线程池的工厂方法

为了防止使用者错误搭配ThreadPoolExecutor构造函数的各个参数以及更加方便简洁的创建ThreadPoolExecutor对象，JavaSE中又定义了Executors类，Eexcutors类提供了创建常用配置线程池的方法。以下是Executors常用的三个创建线程池的源代码。
从源码中可以看出，Executors间接的调用了重载的ThreadPoolExecutor构造函数，并帮助用户根据不同的应用场景，配置不同的参数。
1.newCachedThreadPool：使用SynchronousQueue作为阻塞队列，队列无界，线程的空闲时限为60秒。这种类型的线程池非常适用IO密集的服务，因为IO请求具有密集、数量巨大、不持续、服务器端CPU等待IO响应时间长的特点。服务器端为了能提高CPU的使用率就应该为每个IO请求都创建一个线程，以免CPU因为等待IO响应而空闲。

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

2.newFixedThreadPool：需指定核心线程数，核心线程数和最大线程数相同，使用LinkedBlockingQueue 作为阻塞队列，队列无界，线程空闲时间0秒。这种类型的线程池可以适用CPU密集的工作，在这种工作中CPU忙于计算而很少空闲，由于CPU能真正并发的执行的线程数是一定的（比如四核八线程），所以对于那些需要CPU进行大量计算的线程，创建的线程数超过CPU能够真正并发执行的线程数就没有太大的意义。

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                                  0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

3.newSingleThreadExecutor：池中只有一个线程工作，阻塞队列无界，它能保证按照任务提交的顺序来执行任务。

public static ExecutorService newSingleThreadExecutor() {
    return new FinalizableDelegatedExecutorService
        (new ThreadPoolExecutor(1, 1,
                                0L, TimeUnit.MILLISECONDS,
                                new LinkedBlockingQueue<Runnable>()));
}

4.newScheduleThreadPool:创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

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