ThreadPoolExecutor

为什么使用线程池

new Thread的缺点

• 每次都需要new对象，性能差
• 无附加功能
• 缺乏统一管理，容易造成系统资源占用混乱甚至OOM

线程池

• 减少了创建和销毁线程的次数，让每个线程都可以多次的使用，
• 提高了系统资源利用率。可以根据系统情况自主调整线程的数量，防止消耗过多内存。
• 提供了定时执行、并发控制等功能
  一句话，就是优化了线程的内存开销。

ThreadPoolExecutor

public class ThreadPoolExecutor extends AbstractExecutorService {
    public ThreadPoolExecutor(
      int corePoolSize,                  //线程池中核心线程数的最大值                 
      int maximumPoolSize,               //线程池中能拥有最多线程数 默认为Integer.MAX_VALUE 一般设置为和核心线程数一样
      long keepAliveTime,                //表示空闲线程的存活时间 默认为60s，一般设置为默认60s
      TimeUnit unit,                     //表示keepAliveTime的单位
      BlockingQueue<Runnable> workQueue, //用于缓存任务的阻塞队列
      ThreadFactory threadFactory,       //指定创建线程的工厂(可以不指定)
      RejectedExecutionHandler handler   //拒绝策略
    ) 
}

当线程数 < 核心线程数，创建线程。运行任务，且任务结束后将该线程保留在线程池中，不做销毁处理
当线程数 == 核心线程数 && 任务队列未满，将任务放入任务队列。
当线程数 == 核心线程数 && 任务队列已满 && 当线程数 < 最大线程数，创建线程。
当线程数 > 核心线程数 && 任务队列已满 && 线程数 == 最大线程数，执行拒绝策略。

核心线程数corePoolSize

默认为1。 设置规则：

• CPU密集型 (CPU密集型也叫计算密集型，指的是运算较多，cpu占用高，读/写I/O(硬盘/内存)较少)：corePoolSize = CPU核数 + 1
• IO密集型 (与cpu密集型相反，系统运作，大部分的状况是CPU在等I/O (硬盘/内存) 的读/写操作，此时CPU Loading并不高。）：corePoolSize = CPU核数 * 2

阻塞队列 workQueue

队列，当线程数目超过核心线程数时用于保存任务的队列。（BlockingQueue workQueue）此队列仅保存实现Runnable接口的任务。（因为线程池的底层BlockingQueue的泛型为Runnable）

• 无界队列（LinkedBlockingQueue）
  队列大小无限制，常用的为无界的LinkedBlockingQueue，使用该队列作为阻塞队列时要尤其当心，当任务耗时较长时可能会导致大量新任务在队列中堆积最终导致OOM。阅读代码发现，Executors.newFixedThreadPool 采用就是 LinkedBlockingQueue，而博主踩到的就是这个坑，当QPS很高，发送数据很大，大量的任务被添加到这个无界LinkedBlockingQueue 中，导致cpu和内存飙升服务器挂掉。
  当然这种队列，maximumPoolSize 的值也就无效了。当每个任务完全独立于其他任务，即任务执行互不影响时，适合于使用无界队列；例如，在 Web 页服务器中。这种排队可用于处理瞬态突发请求，当命令以超过队列所能处理的平均数连续到达时，此策略允许无界线程具有增长的可能性。
• 有界队列
  当使用有限的 maximumPoolSizes 时，有界队列有助于防止资源耗尽，但是可能较难调整和控制。常用的有两类，一类是遵循FIFO原则的队列如ArrayBlockingQueue，另一类是优先级队列如PriorityBlockingQueue。PriorityBlockingQueue中的优先级由任务的Comparator决定。
  使用有界队列时队列大小需和线程池大小互相配合，线程池较小有界队列较大时可减少内存消耗，降低cpu使用率和上下文切换，但是可能会限制系统吞吐量。
• 同步移交队列
  如果不希望任务在队列中等待而是希望将任务直接移交给工作线程，可使用SynchronousQueue作为等待队列。SynchronousQueue不是一个真正的队列，而是一种线程之间移交的机制。要将一个元素放入SynchronousQueue中，必须有另一个线程正在等待接收这个元素。只有在使用无界线程池或者有饱和策略时才建议使用该队列。

线程工厂 threadFactory

用来创建线程。
为了统一在创建线程时设置一些参数，如是否守护线程，线程一些特性等，如优先级。通过这个TreadFactory创建出来的线程能保证有相同的特性。它是一个接口类，而且方法只有一个，就是创建一个线程。如果没有另外说明，则在同一个ThreadGroup 中一律使用Executors.defaultThreadFactory() 创建线程，并且这些线程具有相同的NORM_PRIORITY 优先级和非守护进程状态。通过提供不同的 ThreadFactory，可以改变线程的名称、线程组、优先级、守护进程状态，等等。如果从newThread 返回 null 时ThreadFactory 未能创建线程，则执行程序将继续运行，但不能执行任何任务。

拒绝策略 handler

默认是AbortPolicy，会抛出RejectedExecutionException异常。
当线程数已经达到maxPoolSize，且队列已满，会拒绝新任务。
当线程池被调用shutdown()后，会等待线程池里的任务执行完毕再shutdown。如果在调用shutdown()和线程池真正shutdown之间提交任务，会拒绝新任务。

• AbortPolicy 丢弃任务，抛运行时异常。
• CallerRunsPolicy 由当前调用的任务线程执行任务。
• DiscardPolicy 忽视，什么都不会发生。
• DiscardOldestPolicy 从队列中踢出最先进入队列（最后一个执行）的任务。
• 自定义策略

四种调用ThreadPoolExecutor创建线程池方式

newFixedThreadPool

//Executors创建线程
//核心线程数、最大线程数都是传进来的
//空闲线程存活时间0秒
//任务存放在无界LinkedBlockingQueue中
//默认的工厂 默认的拒绝策略
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>(), threadFactory);
}

newSingleThreadExecutor

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

newCachedThreadPool

//没有核心线程数
//最大线程数基本属于无限
//空闲线程等待60s
//SynchronousQueue阻塞队列
//耗时较短的任务。
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                  60L, TimeUnit.SECONDS,
                                  new SynchronousQueue<Runnable>(),
                                  threadFactory);
}

newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
    return new ScheduledThreadPoolExecutor(corePoolSize);
}
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {
    return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public class ScheduledThreadPoolExecutor extends ThreadPoolExecutor implements ScheduledExecutorService {
     public ScheduledThreadPoolExecutor(int corePoolSize, ThreadFactory threadFactory) {
            super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory);
     }    
}

放一起方便记忆（不指定工厂）

// 第一种线程池:固定个数的线程池,可以为每个CPU核绑定一定数量的线程数
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(processors * 2);
// 缓存线程池，无上限
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 单一线程池,永远会维护存在一条线程
ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
// 固定个数的线程池，可以执行延时任务，也可以执行带有返回值的任务。
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

补充源码

public abstract class AbstractExecutorService implements ExecutorService{
    。。。
}

public interface ExecutorService extends Executor {
    void shutdown();//关闭线程池，等待任务都执行完
    List<Runnable> shutdownNow();//关闭线程池，不会等待任务执行完
    boolean isShutdown();
    boolean isTerminated();
    boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;
    <T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException;
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                              long timeout, TimeUnit unit) throws InterruptedException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException;
    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

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