线程池之ThreadPoolExecutor

线程池的优点

• 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 第三：提高系统的客观理性。线程是稀缺资源，如果无限制的创建线程，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行同一分配、调优和监控。但是，要做到合理利用线程池，必须对其实现原理了如指掌。

ThreadPoolExecutor是Executor中最核心的类。


线程有五种状态：新建（new）、就绪（ready）、运行（running）、阻塞（blocing）、死亡（dead）


线程池也有五种状态：RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED

 //记录“线程池中的任务数量”和“线程池的状态”两个信息
 //共32位，其中高3位表示“线程池状态”，低29位标识“线程池中的任务数量”
 private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
 private static final int COUNT_BITS = Integer.SIZE - 3;
 private static final int CAPACITY = (1 << COUNT_BITS) - 1;

// runState is stored in the high-order bits
//处于RUNNING状态的线程池能够接受新任务，以及对新添加的任务进行处理
private static final int RUNNING = -1 << COUNT_BITS; //对应的高3位的值是111
//处于SHUTDOWN状态的线程池不可用接受新任务，但是可以对已添加的任务进行处理
private static final int SHUTDOWN = 0 << COUNT_BITS; //对应的高3位的值是000
//处于STOP状态的线程池不接受新任务，不处理已添加的任务，并且会中断正在处理的任务
private static final int STOP = 1 << COUNT_BITS;     //对应的高3位的值是001
//当所有的任务已终止，ctl记录的“任务数量”位0，线程池状态会变为TIDYING。
//当线程池变为TIDYING状态时，会执行钩子函数terminated()。
// terninated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时进行相应的处理，可以通过重载terminated()方法l来实现
private static final int TIDYING = 2 << COUNT_BITS;  //对应的高3位的值是010
//线程池彻底终止的状态
private static final int TERMINATED = 3 << COUNT_BITS;//对应的高3位的值是011

线程池的执行流程

创建线程池

//corePoolSize：核心线程数。当提交一个任务时，线程池会创建一个核心线程来执行任务，直到当前线程数等于corePoolSize。
//  如果调用了线程池prestartAllCoreThreads()方法，线程池会提前创建并启动所有基本线程
//maximumPoolSize：线程池中允许的最大线程数。线程池的阻塞队列满了之后，如果还有任务提交，如果当前的线程数小于maximumPoolSize
//  则会新建线程来执行任务。注意，如果使用的时无界队列该参数就没有什么效果了
//keepAliveTime：线程空闲的时间。线程的创建和销毁是需要代价的。线程执行完任务后不会立即销毁，而是会存活一段时间：keepAliveTime
//  线程池的工作线程空闲后，保持存活的时间，因此，如果任务很多，并且每个任务执行的时间比较短，可以调大时间，提高线程的利用率。
//unit：线程活动保持时间的单位：可选单位有天（DAYS）、小时（HOURS）、分钟（MINUTES）、毫秒（MILLISECONDS）、微秒（MICROSECONDS,千分之一毫秒）和纳秒（NANOSECONDS，千分之一微秒）
//workQueue：用来保存等待执行任务的阻塞队列，等待的任务必须实现Runnable接口。可选择：ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue、PriorityBlockingQueue
//threadFactor：用于设置创建线程的工厂。该对象可以通过Executors.defaulThreadFactory()
//handler，线程池的拒绝策略。所谓拒绝策略，是指将任务添加到线程池中时，线程池拒绝该任务所采用的相应策略。
// 当队列和线程池都吗满了说明线程池处于饱和状态。纳秒必须采取一种策略处理提交的新任务。
// 这个策略默认是AbortPolicy，表示无法处理新任务时抛出异常。
//  其它策略：
//          CallerRunsPolicy：只用调用者所在线程来运行任务
//          DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务
//          DiscardPolicy：不处理，丢弃掉
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;
}

DefaultFactory的源码如下

static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;
    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
                              Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
                      poolNumber.getAndIncrement() +
                     "-thread-";
    }
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            //非守护线程
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            //优先级都为5
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

向线程池提交任务

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

结束线程池

• shutdown
• shutdownNow

原理是通过遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程，所以无法响应中断的任务可能永远无法终止。
区别是shutdownNow首先将线程池的状态设置位STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表，而shutdown只是将线程池的状态设置成SHUTDOWN状态，然后中断所有没有正在执行的任务的线程。


调用两个方法之后，isShutdown()都会返回true，当所有任务都已关闭后，才表示线程池关闭成功，这时调用isTerminaed()方法会返回true。

合理配置线程池

合理的配置线程池，首先要分析任务特性：

• 任务的性质：CPU密集型任务、IO密集型任务和混合型任务
• 任务的优先级：高、中、低
• 任务的执行时间：长、中、短
• 任务的依赖性：是否依赖其他系统资源，如数据库连接。

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

• CPU密集型任务应配置尽可能小的线程，如配置N+1个线程的线程池。
• 由于IO密集型任务线程并不是一致在执行任务，则应配置尽可能多的线程，如2*N
• 混合型的任务，如果可以拆分，将其拆分成一个CPU密集型任务和一个IO密集型任务，只要这两个任务执行的时间相差不是太大，那么分解后执行的吞吐量将高于串行执行的吞吐量。如果这两个任务执行时间相差太大，则没比较进行分解。

可以通过Runtime.``_getRuntime_``().availableProcessors()获得当前设备的CPU个数。

优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理，它可以让优先级高的任务先执行。

执行时间不同的任务可以交给不同规模的线程池来处理，或者可以使用优先级队列，让执行时间短的任务先执行。

依赖数据库连接池的任务

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

建议使用有界队列

有界队列能增加系统的稳定性和预警能力，可以根据需要设大点。


如果是无界队列，那么当一个业务使线程池满了的话，会导致整个系统不可用；如果是有界的话，只是单个业务不可用而已。