《Java并发编程的艺术》第九章读书笔记——Java中的线程池

在开发过程中，合理地使用线程池能够带来3个好处：

1. 降低资源消耗
2. 提高响应速度
3. 提高线程的可管理性

9.1 线程池的实现原理

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

1. 线程池判断核心线程池里的线程是否都在执行任务，如果没有，则创建新的线程来执行任务，如果核心线程都满了，则进入下一步。
2. 线程池判断当前工作队列是否都满了，如果没有满，则将新提交的任务存储在队列中。如果满了，则进入下一步。
3. 线程池判断线程池的线程是否都处于工作状态，如果没有，则创建一个新的线程执行任务，如果都满了，则交给饱和策略处理这个任务。

9.2 线程池的使用

创建线程池的方法主要是ThreadPoolExecutor类来完成。

new ThreadPoolExecutor(corePoolSiza,maxmumPoolSize,keepAliveTime,
               milliseconds,runnableTaskQueue,handler);

1. corePoolSize：表示核心线程池的大小。当提交一个任务时，如果当前核心线程池的线程个数没有达到corePoolSize，则会创建新的线程来执行所提交的任务，即使当前核心线程池有空闲的线程。如果当前核心线程池的线程个数已经达到了corePoolSize，则不再重新创建线程。如果调用了prestartCoreThread()或者 prestartAllCoreThreads()，线程池创建的时候所有的核心线程都会被创建并且启动。

2. maximumPoolSize：表示线程池能创建线程的最大个数。如果当阻塞队列已满时，并且当前线程池线程个数没有超过maximumPoolSize的话，就会创建新的线程来执行任务。

3. keepAliveTime：空闲线程存活时间。如果当前线程池的线程个数已经超过了corePoolSize，并且线程空闲时间超过了keepAliveTime的话，就会将这些空闲线程销毁，这样可以尽可能降低系统资源消耗。

4. milliseconds：时间单位。为keepAliveTime指定时间单位。

5. runnableTaskQueue：阻塞队列。用于保存任务的阻塞队列，关于阻塞队列可以看这篇文章。可以使用ArrayBlockingQueue, LinkedBlockingQueue, SynchronousQueue, PriorityBlockingQueue。

6. ThreadFactory：创建线程的工程类。可以通过指定线程工厂为每个创建出来的线程设置更有意义的名字，如果出现并发问题，也方便查找问题原因。

7. handler：饱和策略。当线程池的阻塞队列已满和指定的线程都已经开启，说明当前线程池已经处于饱和状态了，那么就需要采用一种策略来处理这种情况。采用的策略有这几种：

• AbortPolicy： 直接拒绝所提交的任务，并抛出RejectedExecutionException异常；
• CallerRunsPolicy：只用调用者所在的线程来执行任务；
• DiscardPolicy：不处理直接丢弃掉任务；
• DiscardOldestPolicy：丢弃掉阻塞队列中存放时间最久的任务，执行当前任务

通过ThreadPoolExecutor创建线程池后，提交任务后执行过程是怎样的，下面来通过源码来看一看。execute方法源码如下：

public void execute(Runnable command) {
    if (command == null)
        throw new NullPointerException();
    /*
     * Proceed in 3 steps:
     *
     * 1. If fewer than corePoolSize threads are running, try to
     * start a new thread with the given command as its first
     * task.  The call to addWorker atomically checks runState and
     * workerCount, and so prevents false alarms that would add
     * threads when it shouldn't, by returning false.
     *
     * 2. If a task can be successfully queued, then we still need
     * to double-check whether we should have added a thread
     * (because existing ones died since last checking) or that
     * the pool shut down since entry into this method. So we
     * recheck state and if necessary roll back the enqueuing if
     * stopped, or start a new thread if there are none.
     *
     * 3. If we cannot queue task, then we try to add a new
     * thread.  If it fails, we know we are shut down or saturated
     * and so reject the task.
     */
    int c = ctl.get();
    //如果线程池的线程个数少于corePoolSize则创建新线程执行当前任务
    if (workerCountOf(c) < corePoolSize) {
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    //如果线程个数大于corePoolSize或者创建线程失败，则将任务存放在阻塞队列workQueue中
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get();
        if (! isRunning(recheck) && remove(command))
            reject(command);
        else if (workerCountOf(recheck) == 0)
            addWorker(null, false);
    }
    //如果当前任务无法放进阻塞队列中，则创建新的线程来执行任务
    else if (!addWorker(command, false))
        reject(command);
}

下图为ThreadPoolExecutor的execute方法的执行示意图：

1. 如果当前运行的线程少于corePoolSize，则创建线程来执行任务，
2. 如果运行的线程等或多于corePoolSize，则将任务加入BolakingQueue。
3. 如果无法将任务加入BlockingQueue，则创建新的线程来处理任务。
4. 如果创建新线程将使当前运行的线程超出maxmunPoolSize，任务被拒绝，并调用策略。

TheadPoolExecutor采取这种设计思路，是为了在执行execute()方法时，尽可能地避免获取全局锁。

9.3 线程池的关闭

可以通过调用线程池的shutdown或shutdownNow方法来关闭线程池。它们的原理是遍历线程池中的工作线程，然后逐个调用线程的interrupt方法来中断线程。

1. shutdownNow首先将线程池的状态设置为STOP,然后尝试停止所有的正在执行和未执行任务的线程，并返回等待执行任务的列表；
2. shutdown只是将线程池的状态设置为SHUTDOWN状态，然后中断所有没有正在执行任务的线程

9.4 合理的配置线程池

要想合理的配置线程池，就必须首先分析任务特性，可以从以下几个角度来进行分析：

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