Java并发编程——线程池与Executor

降低资源消耗——通过调高已经创建的线程的复用率实现
提高响应速度——任务到达时，不需要创建新线程。
提高线程的可管理性——使用线程池统一分配，调优和监控

线程池核心参数

corePoolSize

线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于
corePoolSize；如果当前线程数为corePoolSize，继续提交的任务被保存到 阻塞队列中，等待被执行；
如果执行了线程池的prestartAllCoreThreads()方法，线程池会 提前创建并启动所有核心线程。

maximumPoolSize

线程池中允许的最大线程数。
如果当前阻塞队列满了，且继续提交任务，则创建新的线 程执行任务，前提是当前线程数小于maximumPoolSize；

keepAliveTime 与 unit

线程池维护工作线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超keepAliveTime；
unit是keepAliveTime的单位；

runnableTaskQueue

用来保存等待被执行的任务的阻塞队列，且任务必须实现Runable接口，在JDK中提供 了如下阻塞队列：

• 1、ArrayBlockingQueue：基于数组结构的有界阻塞队列，按FIFO排序任务；
• 2、LinkedBlockingQuene：基于链表结构的阻塞队列，按FIFO排序任务，吞 吐量通常要高于ArrayBlockingQuene；
• 3、SynchronousQuene：一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 LinkedBlockingQuene；
• 4、priorityBlockingQuene：具有优先级的无界阻塞队列；

threadFactory

它是ThreadFactory类型的变量，用来创建新线程。默认使用 Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程 时，会使新创建的线程具有相同的NORM_PRIORITY优先级并且是非守护线程，同时也设置了线程1的名称。

RejectedExecutionHandler(饱和策略)

首先是核心线程已经满了，其次是等待队列满了，再其次是线程数已经达到最大线程数，那么只能执行饱和策略。

• 1、AbortPolicy：直接抛出异常，默认策略；
• 2、CallerRunsPolicy：只要线程池未关闭，该策略直接在调用者线程中，运行当前被丢弃的任务。
• 3、DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
• 4、DiscardPolicy：直接丢弃任务；

线程池的处理流程

提交一个任务到线程池

• 判断核心线程是否都在执行了。如果不是，则使用核心线程执行；否则进入下个流程
• 当核心线程都被占用，判断工作队列是否已满。如果工作队列没满，则将新任务存储在工作队列中。如果工作队列 满了，则执行下一步。
• 判断线程池中所有线程是否都处于工作状态，如果没有，则创建一个新的线程池。如果满了，就走饱和策略。

Executor框架成员

ThreadPoolExecutor

通常使用工厂类Executors来创建。Executors可以创建三种类型的ThreadPoolExecutor：

SingleThreadExecutor

创建使用单个线程的线程池。
LinkedBlockingQueue
适用于需要顺序的执行各个任务，并且在任意时间点，不会有多个线程是活动的应用场景。

 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));
    }

FixedThreadPool

创建使用固定线程数的线程池。
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);
    }

CachedThreadPool

创建大小无界的线程池。
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);
    }

ScheduledThreadPoolExecutor

DelayedWorkQueue

public class ScheduledThreadPoolExecutor
        extends ThreadPoolExecutor
        implements ScheduledExecutorService 

ScheduledThreadPoolExecutor

包含若干个线程的ScheduledThreadPoolExecutor。
适用于需要多个后台线程执行周期任务，同时为了满足资源管理的需求而需要限制后台线程数量的应用场景。

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
 public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

SingleThreadScheduledExecutor

只包含一个线程的ScheduledThreadPoolExecutor。
适用于单个后台执行周期任务，同时需要保证顺序的执行各个任务。

public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));
    }
public static ScheduledExecutorService newSingleThreadScheduledExecutor(ThreadFactory threadFactory) {
        return new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1, threadFactory));
    }

Future接口和实现类FutureTask

用来表示异步计算的结果。

Runnable接口 和 Callable接口

都可以被ThreadPoolExecutor或者ScheduledThreadPoolExecutor执行。但是Runnable不会有返回结果；Callable可以返回结果。

Executors

Executor的工厂类，