线程池（一）：Executor原理

线程池是什么

线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。

new Thread的弊端

• 每次new Thread 新建对象，性能差
• 线程缺乏统一管理，可能无限制的新建线程，相互竞争，可能占用过多的系统资源导致死机或者OOM（out of memory内存溢出）。（这种问题的原因不是因为单纯的new一个Thread，而是可能因为程序的bug或者设计上的缺陷导致不断new Thread造成的）
• 缺少更多功能，如更多执行、定期执行、线程中断。

线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。

线程池的好处

1. 降低资源消耗。通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。
2. 提高响应速度。当任务到达时，无需等待线程创建即可立即执行。
3. 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一分配、调优和监控。（并发数控制，定时/定期执行等）
4. 提供更多更强大的功能。线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。

线程池类图

常用最下边的Executors,用它来创建线程池使用线程。
Executor框架，根据一组执行策略的调用调度执行和控制异步任务，目的是提供一种将任务提交与任务运行分离开的机制。

• Executor:运行新任务的简单接口

public interface Executor {void execute(Runnable command);}

• ExecutorService：扩展了Executor，添加了用来管理执行器生命周期和任务生命周期的方法

public interface ExecutorService extends Executor

• ScheduledExecutorService：扩展了ExecutorService，支持Future和定期执行任务

public interface ScheduledExecutorService extends ExecutorService

线程池的实现原理

ThreadPoolExecutor

corePoolSize、maximumPoolSize、workQueue 关系：

• corePoolSize（核心线程数、基本线程数）：当提交一个任务到线程池时，线程池会创建一个线程来执行任务（即使有空闲的基本线程。当任务数大于corePoolSize时就不再创建）。如果调用了线程池prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程。
• Queue(任务队列) ：workQueue阻塞队列，存储等待执行的任务(运行中的线程数大于corePoolSize且小于maximumPoolSize时)

吞吐量：SynchronousQueue高于LinkedBlockingQueue高于ArrayBlockingQueue

• maximumPoolSize：线程最大线程数。如果队列满了，并且已创建的线程数小于最大线程数，则线程池会再创建新的线程执行任务。（如果使用了无界的任务队列，能够创建的最大线程数为corePoolSize,这时maximumPoolSize就不会起作用）

线程池的创建

我们可以通过ThreadPoolExecutor来创建一个线程池。
ThreadPoolExecutor提供了4个有参构造方法（入参区别）

/**   
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

ThreadFactory：线程工厂,设置创建线程，可以通过线程工厂给每个创建出来的线程设置名称。开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线程设置有意义的名字，代码如下。

new ThreadFactoryBuilder().setNameFormat("XX-task-%d").build();

RejectedExecutionHandler:4种拒绝策略

keepAliveTime（线程活动保持时间）：线程池的工作线程(即：非核心线程)空闲后，保持存活的时间。所以，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。

TimeUnit:keepAliveTime的时间单位

工厂类Executors三种静态方法详解

向线程池提交任务

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。
通过以下代码可知execute()方法输入的任务是一个Runnable类的实例。

threadsPool.execute(new Runnable() {
	@Override
	public void run() {
		// TODO Auto-generated method stub
	}
});

submit()方法用于提交需要返回值的任务。线程池会返回一个future 类型的对象，通过这个future对象可以判断任务是否执行成功，并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完。

Future<Object> future = executor.submit(harReturnValuetask);
	try {
		Object s = future.get();//获取返回值
	} catch (InterruptedException e) {
		// 处理中断异常
	} catch (ExecutionException e) {
		// 处理无法执行任务异常
	} finally {
		// 关闭线程池
		executor.shutdown();
	}

线程池生命周期

/*   
	 *	 RUNNING:  Accept new tasks and process queued tasks
     *   SHUTDOWN: Don't accept new tasks, but process queued tasks
     *   STOP:     Don't accept new tasks, don't process queued tasks,
     *             and interrupt in-progress tasks
     *   TIDYING:  All tasks have terminated, workerCount is zero,
     *             the thread transitioning to state TIDYING
     *             will run the terminated() hook method
     *   TERMINATED: terminated() has completed
     */
//volatile int runState;//ForkJoinPool类中;表示当前线程池的状态 ，volatile 修饰用来保证线程之间的可见性
// runState is stored in the high-order bits
private static final int COUNT_BITS = Integer.SIZE - 3;
//当创建线程池后，初始时，线程池处于RUNNING状态
private static final int RUNNING    = -1 << COUNT_BITS;
private static final int SHUTDOWN   =  0 << COUNT_BITS;
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;

 /*
     * RUNNING -> SHUTDOWN
     *    On invocation of shutdown(), perhaps implicitly in finalize()
     * (RUNNING or SHUTDOWN) -> STOP
     *    On invocation of shutdownNow()
     * SHUTDOWN -> TIDYING
     *    When both queue and pool are empty
     * STOP -> TIDYING
     *    When pool is empty
     * TIDYING -> TERMINATED
     *    When the terminated() hook method has completed
     */

关闭线程池：
shutdown或shutdownNow方法关闭线程池。
原理:遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。

区别

• shutdownNow()将线程池的状态设置成STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表
• shutdown()将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行任务的线程。
  

  /**
     * Initiates an orderly shutdown in which previously submitted
     * tasks are executed, but no new tasks will be accepted.
     * Invocation has no additional effect if already shut down.
     */
    public void shutdown() {
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(SHUTDOWN);
            interruptIdleWorkers();
            onShutdown(); // hook for ScheduledThreadPoolExecutor
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
    }

  /**
     * Attempts to stop all actively executing tasks, halts the
     * processing of waiting tasks, and returns a list of the tasks
     * that were awaiting execution. These tasks are drained (removed)
     * from the task queue upon return from this method.
     */
    public List<Runnable> shutdownNow() {
        List<Runnable> tasks;
        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            checkShutdownAccess();
            advanceRunState(STOP);
            interruptWorkers();
            tasks = drainQueue();
        } finally {
            mainLock.unlock();
        }
        tryTerminate();
        return tasks;
    }

合理地配置线程池

如何合理设置线程池大小
创建多少个线程合适？

要充分的利用 CPU 和 I/O

必须首先分析任务特性，从以下几个角度来分析：

• 任务的性质：CPU密集型(CPU运算占比大)、IO密集型（ I/O 操作占比大）和混合型。
• 任务的优先级：高、中和低。
• 任务的执行时间：长、中和短。
• 任务的依赖性：是否依赖其他系统资源，如数据库连接。

单核CPU处理CPU密集型程序，这种情况并不太适合使用多线程（上下文切换开销）
多核CPU处理CPU密集型程序，可以最大化利用 CPU核心数，提高效率
线程等待时间所占比例越高（ I/O 操作耗时），需要越多线程（I/O密集型）；线程CPU时间所占比例越高，需要越少线程（CPU密集型）。

性质不同的任务可以用不同规模的线程池分开处理。

• CPU密集型任务应配置尽可能小的线程，如配置Ncpu+1个线程的线程池。

CPU 核数+ 1原因：
计算(CPU)密集型的线程恰好在某时因为发生一个页错误或者因其他原因而暂停，刚好有一个“额外”的线程，可以确保在这种情况下CPU周期不会中断工作。

• 由于IO密集型任务线程并不是一直在执行任务，则应配置尽可能多的线程，如2*Ncpu+1。

IO操作不占用CPU，不要让CPU闲下来，应加大线程数量

• 混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没必要进行分解。

• 依赖数据库连接池的任务，因为线程提交SQL后需要等待数据库返回结果，等待的时间越长，则CPU空闲时间就越长，那么线程数应该设置得越大，这样才能更好地利用CPU。

可以通过Runtime.getRuntime().availableProcessors()方法获得当前设备的CPU个数。
优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理。
注意：如果一直有优先级高的任务提交到队列里，那么优先级低的任务可能永远不能执行。

建议使用有界队列
最大maximumPoolSize，能增加系统的稳定性和预警能力，能够降低资源消耗但是这种方式使得线程池对线程调度变的更困难。
想让【线程池的吞吐率】【处理任务】达到一个合理的范围，使【线程调度相对简单】【尽可能降低资源消耗】合理限制【线程池】与【队列容量】

分配技巧

1. 降低资源消耗【cpu使用率、操作系统资源的消耗、上下文切换的开销】设置一个【较大的队列容量】【较小线程池容量】降低线程池吞吐量
2. 提交的任务经常发生阻塞，可以调整maximumPoolSize
3. 队列容量较小，需要把线程池大小设置的大一些，这样cpu的使用率相对来说会高一些
4. 如果线程池的容量设置的过大，提高任务的数量过多的时候，并发量会增加，需要考虑线程之间的调度。这样反而可能会降低处理任务的吞吐量。

线程池的监控

·taskCount：线程池需要执行的任务数量。
·completedTaskCount：线程池在运行过程中已完成的任务数量，小于或等于taskCount。
·largestPoolSize：线程池里曾经创建过的最大线程数量。通过这个数据可以知道线程池是否曾经满过。如该数值等于线程池的最大大小，则表示线程池曾经满过。
·getPoolSize：线程池的线程数量。如果线程池不销毁的话，线程池里的线程不会自动销毁，所以这个大小只增不减。
·getActiveCount：获取活动的线程数。

通过扩展线程池进行监控。可以通过继承线程池来自定义线程池，重写线程池的beforeExecute、afterExecute和terminated方法，也可以在任务执行前、执行后和线程池关闭前执行一些代码来进行监控。例如，监控任务的平均执行时间、最大执行时间和最小执行时间等。

protected void beforeExecute(Thread t, Runnable r) {
	这几个方法在线程池里是空方法。
 }