多线程及并发编程之线程池一

为什么使用线程池呢？

Java中的线程池是运用场景最多的并发框架，但思考下为什么要使用线程池呢？

（1）降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。

（3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

但是如果想要合理的使用线程池必须呀要理解其原理,才能应用的得心应手 ；

线程池的实现原理

思考下：在使用线程池的情况下，当向线程池中提交一个任务后，线程池是如何处理这个任务的呢？看下图：

从图中可以看出，当提交一个新任务到线程池时，线程池的处理流程如下。

1）线程池判断核心线程池里的线程是否都在执行任务。如果不是，则创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。

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

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

了解了线程池的原理，那么线程池是如何执行的呢？

线程池的真正实现类是 ThreadPoolExecutor(后文做详解)，那基于ThreadPoolExecutor 是如何实现线程池的执行过程呢？参考下图：

主线程通过execute()、submit()方法(思考两个方法的区别)来提交一个任务到线程池，然后经历1 2 3 4过程来实现线程的执行（是不是和线程池实现原理一样呢？），详细分析下：

ThreadPoolExecutor执行execute、submit()方法分下面4种情况。

1）如果当前运行的线程少于corePoolSize，则创建新线程来执行任务（注意，执行这一步骤 需要获取全局锁）。（ 这一步不太理解，欢迎大家解答）

2）如果运行的线程等于或多于corePoolSize，则将任务加入BlockingQueue。

3）如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务（注意，执行这一步骤需要获取全局锁）。

4）如果创建新线程将使当前运行的线程超出maximumPoolSize，任务将被拒绝，并调用 RejectedExecutionHandler.rejectedExecution()方法。

ThreadPoolExecutor采取上述步骤的总体设计思路，是为了在执行execute()方法时，尽可能 地避免获取全局锁（那将会是一个严重的可伸缩瓶颈）。在ThreadPoolExecutor完成预热之后 （当前运行的线程数大于等于corePoolSize），几乎所有的execute()方法调用都是执行步骤2，而 步骤2不需要获取全局锁。

源码分析：上面的流程分析让我们很直观地了解了线程池的工作原理，让我们再通过源代 码来看看是如何实现的，线程池执行任务的方法如下。

public void execute(Runnable command) { 
    if (command == null) 
        throw new NullPointerException(); 
    // 如果线程数小于基本线程数，则创建线程并执行当前任务 
    if (poolSize >= corePoolSize || !addIfUnderCorePoolSize(command)) { 
        // 如线程数大于等于基本线程数或线程创建失败，则将当前任务放到工作队列中。 
        if (runState == RUNNING && workQueue.offer(command)) { 
            if (runState != RUNNING || poolSize == 0) 
                    ensureQueuedTaskHandled(command); 
        } 
        // 如果线程池不处于运行中或任务无法放入队列，并且当前线程数量小于最大允许的线程数量， 
        // 则创建一个线程执行任务。 
        else if (!addIfUnderMaximumPoolSize(command)) 
            // 抛出RejectedExecutionException异常 
            reject(command); // is shutdown or saturated 
    } 
} 

需要提一下的：线程池中执行任务的线程是工作线程；工作线程：线程池创建线程时，会将线程封装成工作线程Worker，Worker在执行完任务

后，还会循环获取工作队列里的任务来执行。我们可以从Worker类的run()方法里看到这点。

public void run() { 
    try {
        Runnable task = firstTask; 
        firstTask = null; 
        while (task != null || (task = getTask()) != null) { 
            runTask(task);
            task = null; 
        } 
    } finally { 
        workerDone(this); 
    } 
}

线程池的使用

线程池的创建

了解完了线程池的执行过程，我们来了解下创建ThreadPoolExecutor有哪些方法：其构造方法有如下4种：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          ThreadFactory threadFactory) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, defaultHandler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue workQueue,
                          RejectedExecutionHandler handler) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,Executors.defaultThreadFactory(), handler);
}
 
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue 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;
}

从上述的构造方法中，我们可以得出几个创建线程池的重要参数 corePoolSize, maximumPoolSize, keepAliveTime, timeUnit,workQueue, threadFactory,rejectedExecutionHandler；为了创建合理的线程池，我们需要详细了解下以上参数的意义；

• corePoolSize(必需)：线程池中的核心线程数，当提交一个任务时，线程池创建一个新线程执行任务，直到当前线程数等于corePoolSize, 即使有其他空闲线程能够执行新来的任务, 也会继续创建线程；如果当前线程数为corePoolSize，继续提交的任务被保存到阻塞队列中，等待被执行；如果执行了线程池的prestartAllCoreThreads()方法，线程池会提前创建并启动所有核心线程。 注意一点核心线程数 一旦创建后，默认情况下，核心线程会一直存活 不会随着任务的减少（小于核心线程数）而中断，会继续存活，等待新的任务加入到线程池 ，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
• maximumPoolSize(必需)：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。注意：与核心线程不同的是，非核心线程会随着任务的减少的中断，也就是线程闲置时，超过keepAliveTime 指定值，将会被回收。
• keepAliveTime(必需)：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
• unit（必需）：指定 keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）TimeUnit.MINUTES（分）。
• threadFactory(可选)：用于设置创建线程的工厂，可以通过线程工厂给每个创建出来的线程设更有意义的名字。使用开源框架guava提供的ThreadFactoryBuilder可以快速给线程池里的线 程设置有意义的名字，代码如下。

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

• workQueue (必需)：用来保存等待被执行的任务的阻塞队列. 在JDK中提供了如下阻塞队列: 具体可以参考JUC 集合: BlockQueue详解

任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。

• ArrayBlockingQueue: 基于数组结构的有界阻塞队列，按 先进先出FIFO排序任务；
• LinkedBlockingQuene: 基于链表结构的阻塞队列，按先进先出FIFO排序任务，吞吐量通常要高于ArrayBlockingQuene；
• SynchronousQuene: 一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于LinkedBlockingQuene； 静态工厂方法Executors.newCachedThreadPool使用了这个队列
• PriorityBlockingQuene: 具有优先级的无界阻塞队列；
• LinkedBlockingQueue比ArrayBlockingQueue在插入删除节点性能方面更优，但是二者在put(), take()任务的时均需要加锁，
• SynchronousQueue使用无锁算法，根据节点的状态判断执行，而不需要用到锁，其核心是Transfer.transfer().

LinkedBlockingQueue比ArrayBlockingQueue在插入删除节点性能方面更优，但是二者在put(), take()任务的时均需要加锁，

SynchronousQueue使用无锁算法，根据节点的状态判断执行，而不需要用到锁，其核心是Transfer.transfer().

• rejectedExecutionHandler(可选)：拒绝策略。当达到最大线程数时需要执行的饱和策略。当队列和线程池都满了，说明线程池处于饱和状

态，那么必须采取一种策略处理提交的新任务。这个策略默认情况下是AbortPolicy，表示无法处理新任务时抛出异常。

在JDK 1.5中Java线程池框架提供了以下4种策略。

• AbortPolicy：直接抛出异常。 (默认)
• CallerRunsPolicy：只用调用者所在线程来运行任务。
• DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。
• DiscardPolicy：不处理，直接丢弃掉。

当然，也可以根据应用场景需要来实现RejectedExecutionHandler接口自定义策略。如记录日志或持久化存储不能处理的任务。

上面介绍的是通过ThreadPoolExecutor 创建线程池的方法，也是推荐创建线程池的方式，这样有助于我们全面了解线程池。

Java中还有一个别的方式可以创建线程池，可以作为了解：从ThreadPoolExecutor的构造方法中有一个工具类：Executors，可以通过该工具类创建以下几种类型的线程池

newFixedThreadPool （固定大小的线程池）

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

线程池的线程数量达corePoolSize后，即使线程池没有可执行任务时，也不会释放线程。

FixedThreadPool的工作队列为无界队列 LinkedBlockingQueue(队列容量为Integer.MAX_VALUE), 这会导致以下问题:

• 线程池里的线程数量不超过corePoolSize,这导致了maximumPoolSize和keepAliveTime将会是个无用参数
• 由于使用了无界队列, 所以FixedThreadPool永远不会拒绝, 即饱和策略失效

newSingleThreadExecutor （单个线程的线程池）

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

初始化的线程池中只有一个线程，如果该线程异常结束，会重新创建一个新的线程继续执行任务，唯一的线程可以保证所提交任务的顺序执行。

由于使用了无界队列, 所以SingleThreadPool永远不会拒绝, 即饱和策略失效

newCachedThreadPool

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

线程池的线程数可达到Integer.MAX_VALUE，即2147483647，内部使用SynchronousQueue作为阻塞队列；和newFixedThreadPool创建的线程池不同，newCachedThreadPool在没有任务执行时，当线程的空闲时间超过keepAliveTime，会自动释放线程资源，当提交新任务时，如果没有空闲线程，则创建新线程执行任务，会导致一定的系统开销；执行过程与前两种稍微不同:

• 主线程调用SynchronousQueue的offer()方法放入task, 倘若此时线程池中有空闲的线程尝试读取 SynchronousQueue的task, 即调用了SynchronousQueue的poll(), 那么主线程将该task交给空闲线程. 否则执行(2)
• 当线程池为空或者没有空闲的线程, 则创建新的线程执行任务.
• 执行完任务的线程倘若在60s内仍空闲, 则会被终止. 因此长时间空闲的CachedThreadPool不会持有任何线程资源.

ScheduledThreadPool 定时线程池 (之后详细说明)

上面说过了线程池的创建，接下来说下：

线程的提交

首先线程提交共有两种方式，上面讲述ThreadPoolExecutor 我们说过，

也就是：execute()、submit()方法;那么这两种方法有什么不同呢？

推荐参考：线程池的submit和execute的区别_guhong5153的博客-CSDN博客_线程池submit和execute区别https://blog.csdn.net/guhong5153/article/details/71247266

execute()方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功。

通过以下代码可知execute()方法： 输入的任务是一个Runnable类的实例。 通过Runnable 接口的run方法可以明白，execute()方法没有返回值的原因；

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

submit()方法用于提交需要返回值的任务。线程池会返回一个future类型的对象，通过这个 future对象可以判断任务是否执行成功;注意下：

• 使用submit方法的话，任务类是必须实现Callable接口还是Callable和Runnable接口都可以呢？
  • 都可以，但是想要拿到返回值的话只能用callable

并且可以通过future的get()方法来获取返回值，get()方法会阻塞当前线程直到任务完成，

而使用get（long timeout，TimeUnit unit）方法则会阻塞当前线 程一段时间后立即返回，这时候有可能任务没有执行完。

Future