别再说你不懂线程池——做个优雅的攻城狮

傷城~ 2022-05-31 05:14 262阅读 0赞

作者：爱撸铁的攻城狮  
链接：[https://juejin.im/post/5a743c526fb9a063557d7eba][https_juejin.im_post_5a743c526fb9a063557d7eba]  
来源：掘金

# 什么是线程池 #

线程池，顾名思义就是装线程的池子。其用途是为了帮我们重复管理线程，避免创建大量的线程增加开销，提高响应速度。  
![1][]

# 为什么要用线程池 #

作为一个严谨的攻城狮，不会希望别人看到我们的代码就开始吐槽，new Thread().start()会让代码看起来混乱臃肿，并且不好管理和维护，那么我们就需要用到了线程池。  
在编程中经常会使用线程来异步处理任务，但是每个线程的创建和销毁都需要一定的开销。如果每次执行一个任务都需要开一个新线程去执行，则这些线程的创建和销毁将消耗大量的资源；并且线程都是“各自为政”的，很难对其进行控制，更何况有一堆的线程在执行。线程池为我们做的，就是线程创建之后为我们保留，当我们需要的时候直接拿来用，省去了重复创建销毁的过程。

# 线程池的处理逻辑 #

## 线程池ThreadPoolExecutor构造函数 ##

//五个参数的构造函数
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue)
    
    //六个参数的构造函数-1
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory)
    
    //六个参数的构造函数-2
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler)
    
    //七个参数的构造函数
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler)

虽然参数多，只是看着吓人，其实很好理解，下面会一一解答。

我们拿最多参数的来说：

### 1. corePoolSize -> 该线程池中核心线程数最大值 ###

核心线程：默认情况下，会一直存在于线程池中（即使这个线程啥都不干），有任务要执行时，如果核心线程没有被占用，会优先用核心线程执行任务。数量一般情况下设置为CPU核数的二倍即可。

### 2. maximumPoolSize -> 该线程池中线程总数最大值 ###

线程总数=核心线程数+非核心线程数

非核心线程：简单理解，即核心线程都被占用，但还有任务要做，就创建非核心线程

### 3. keepAliveTime -> 非核心线程闲置超时时长 ###

这个参数可以理解为，任务少，但池中线程多，非核心线程不能白养着，超过这个时间不工作的就会被干掉，但是核心线程会保留。

### 4. TimeUnit -> keepAliveTime的单位 ###

TimeUnit是一个枚举类型，其包括:  
NANOSECONDS ： 1微毫秒 = 1微秒 / 1000  
MICROSECONDS ： 1微秒 = 1毫秒 / 1000  
MILLISECONDS ： 1毫秒 = 1秒 /1000  
SECONDS ： 秒  
MINUTES ： 分  
HOURS ： 小时  
DAYS ： 天

### 5. BlockingQueue workQueue -> 线程池中的任务队列 ###

默认情况下，任务进来之后先分配给核心线程执行，核心线程如果都被占用，并不会立刻开启非核心线程执行任务，而是将任务插入任务队列等待执行，核心线程会从任务队列取任务来执行，任务队列可以设置最大值，一旦插入的任务足够多，达到最大值，才会创建非核心线程执行任务。

常见的 workQueue 有四种：

1.  `SynchronousQueue`：这个队列接收到任务的时候，会直接提交给线程处理，而不保留它，如果所有线程都在工作怎么办？那就新建一个线程来处理这个任务！所以为了保证不出现 线程数达到了 `maximumPoolSize` 而不能新建线程的错误，使用这个类型队列的时候，`maximumPoolSize` 一般指定成 `Integer.MAX_VALUE`，即无限大
2.  `LinkedBlockingQueue`：这个队列接收到任务的时候，如果当前线程数小于核心线程数，则新建线程（核心线程）处理任务；如果当前线程数等于核心线程数，则进入队列等待。由于这个队列没有最大值限制，即所有超过核心线程数的任务都将被添加到队列中，这也就导致了 `maximumPoolSize` 的设定失效，因为总线程数永远不会超过 `corePoolSize`
3.  `ArrayBlockingQueue`：可以限定队列的长度，接收到任务的时候，如果没有达到 `corePoolSize` 的值，则新建线程（核心线程）执行任务，如果达到了，则入队等候，如果队列已满，则新建线程（非核心线程）执行任务，又如果总线程数到了 `maximumPoolSize`，并且队列也满了，则发生错误，或是执行实现定义好的饱和策略
4.  `DelayQueue`：队列内元素必须实现 `Delayed` 接口，这就意味着你传进去的任务必须先实现 `Delayed` 接口。这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

### 6. ThreadFactory threadFactory -> 创建线程的工厂 ###

可以用线程工厂给每个创建出来的线程设置名字。一般情况下无须设置该参数。

### 7. RejectedExecutionHandler handler -> 饱和策略 ###

这是当任务队列和线程池都满了时所采取的应对策略，默认是 `AbordPolicy`， 表示无法处理新任务，并抛出 `RejectedExecutionException` 异常。此外还有 3 种策略，它们分别如下。

1.  `CallerRunsPolicy`：用调用者所在的线程来处理任务。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
2.  `DiscardPolicy`：不能执行的任务，并将该任务删除。
3.  `DiscardOldestPolicy`：丢弃队列最近的任务，并执行当前的任务。

别晕，接下来上图，相信结合图你能大彻大悟~  
![1615a238f18d53c9_imageslim][]

# 如何使用线程池 #

说了半天原理，接下来就要用了，java 为我们提供了 4 种线程池 `FixedThreadPool`、`CachedThreadPool`、`SingleThreadExecutor`、`ScheduledThreadPool`，几乎可以满足我们大部分的需要了：

## 1. FixedThreadPool ##

可重用固定线程数的线程池，超出的线程会在队列中等待，在Executors类中我们可以找到创建方式：

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

`FixedThreadPool` 的 `corePoolSize` 和 `maximumPoolSize` 都设置为参数 `nThreads`，也就是只有固定数量的核心线程，不存在非核心线程。`keepAliveTime` 为 `0L` 表示多余的线程立刻终止，因为不会产生多余的线程，所以这个参数是无效的。`FixedThreadPool` 的任务队列采用的是 `LinkedBlockingQueue`。

![1 1][]

创建线程池的方法，在我们的程序中只需要，后面其他种类的同理：

public static void main(String[] args) {
            // 参数是要线程池的线程最大值
            ExecutorService executorService = Executors.newFixedThreadPool(10);
    }

## 2. CachedThreadPool ##

`CachedThreadPool` 是一个根据需要创建线程的线程池

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

`CachedThreadPool` 的 `corePoolSize` 是 `0`，`maximumPoolSize` 是 `Int` 的最大值，也就是说 `CachedThreadPool` 没有核心线程，全部都是非核心线程，并且没有上限。`keepAliveTime` 是 `60` 秒，就是说空闲线程等待新任务 `60` 秒，超时则销毁。此处用到的队列是阻塞队列 `SynchronousQueue`，这个队列没有缓冲区，所以其中最多只能存在一个元素,有新的任务则阻塞等待。

![1 2][]

## 3. SingleThreadExecutor ##

`SingleThreadExecutor` 是使用单个线程工作的线程池。其创建源码如下：

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

我们可以看到总线程数和核心线程数都是 `1`，所以就只有一个核心线程。该线程池才用链表阻塞队列 `LinkedBlockingQueue`，先进先出原则，所以保证了任务的按顺序逐一进行。

![1 3][]

## 4. ScheduledThreadPool ##

`ScheduledThreadPool` 是一个能实现定时和周期性任务的线程池，它的创建源码如下：

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

这里创建了 `ScheduledThreadPoolExecutor`，继承自 `ThreadPoolExecutor`，主要用于定时延时或者定期处理任务。`ScheduledThreadPoolExecutor` 的构造如下：

public ScheduledThreadPoolExecutor(int corePoolSize) {
            super(corePoolSize, Integer.MAX_VALUE,
                  DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
                  new DelayedWorkQueue());
        }

可以看出 `corePoolSize` 是传进来的固定值，`maximumPoolSize` 无限大，因为采用的队列 `DelayedWorkQueue` 是无解的，所以 `maximumPoolSize` 参数无效。该线程池执行如下：

![1 4][]

当执行 `scheduleAtFixedRate` 或者 `scheduleWithFixedDelay` 方法时，会向 `DelayedWorkQueue` 添加一个实现 `RunnableScheduledFuture` 接口的 `ScheduledFutureTask` （任务的包装类），并会检查运行的线程是否达到 `corePoolSize`。如果没有则新建线程并启动 `ScheduledFutureTask`，然后去执行任务。如果运行的线程达到了 `corePoolSize` 时，则将任务添加到 `DelayedWorkQueue` 中。`DelayedWorkQueue` 会将任务进行排序，先要执行的任务会放在队列的前面。在跟此前介绍的线程池不同的是，当执行完任务后，会将 `ScheduledFutureTask` 中的 `time` 变量改为下次要执行的时间并放回到 `DelayedWorkQueue` 中。

# 如何合理配置线程池的大小 #

一般需要根据任务的类型来配置线程池大小：  
如果是 CPU 密集型任务，就需要尽量压榨 CPU，参考值可以设为 NCPU + 1  
如果是 IO 密集型任务，参考值可以设置为 2 \* NCPU  
当然，这只是一个参考值，具体的设置还需要根据实际情况进行调整，比如可以先将线程池大小设置为参考值，再观察任务运行情况和系统负载、资源利用率来进行适当调整。

# 结语 #

java为我们提供的线程池就介绍到这了，墙裂建议大家还是动手去敲一敲，毕竟实践过心里才有底。

[https_juejin.im_post_5a743c526fb9a063557d7eba]: https://juejin.im/post/5a743c526fb9a063557d7eba
[1]: https://user-gold-cdn.xitu.io/2018/2/3/16159ea09e3e78c7?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1615a238f18d53c9_imageslim]: https://user-gold-cdn.xitu.io/2018/2/3/1615a238f18d53c9?imageslim
[1 1]: https://user-gold-cdn.xitu.io/2018/2/3/1615a7fcb4af71c6?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 2]: https://user-gold-cdn.xitu.io/2018/2/7/1616e2b8b89d971c?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 3]: https://user-gold-cdn.xitu.io/2018/2/7/1616e43b53271671?imageView2/0/w/1280/h/960/format/webp/ignore-error/1
[1 4]: https://user-gold-cdn.xitu.io/2018/2/7/1616e5ded43058a5?imageView2/0/w/1280/h/960/format/webp/ignore-error/1