并发编程3：线程池的使用与执行流程

一时失言乱红尘 2022-06-14 11:10 110阅读 0赞

并发编程系列的文章酝酿好久了，但由于没有时间和毅力去写那么多练习 demo，很多文章写了一半就停止了。

在写某一系列的过程中总有其他想写的内容蹦出来，想忍住不分散精力太难了，所以我很佩服那些能专心研究、总结一个专题的人，他们是有毅力的人！

关于学习的方式我也困惑过很久，究竟是知识体系驱动还是项目驱动比较好呢？

*  知识体系驱动即一条道走到头的学习（逮住某个专题深入研究，直到整个过一遍）
 *  项目驱动即以完成项目为目的，中间需要用到什么再去研究什么

很多人建议项目驱动，因为那样可以理论和实践结合。但我尝试了一下就放弃了，因为在不了解整个知识体系前，你遇到问题也不知道该如何选型，中间耽搁的时间可能更多。

于是想出了新的学习方式 – **开源项目分析型**:

以分析常用的开源项目为总线，了解这些项目使用什么技术、这个技术是什么、有什么需要注意的地方，在遇到自己不熟悉的就学习总结一下，这样就可以有的放矢，不至于太过漫长看不到结尾。

好了言归正传，这篇文章将介绍下并发编程中最常使用的线程池。

关联文章：

*  [ 趣谈并发1：全面认识 Thread][_1_ Thread]
 *  [ 趣谈并发2：认识并发编程的利与弊][_2]

读完本文你将了解：

*  什么是线程池
 *  线程池的处理流程
 *  保存待执行任务的阻塞队列
 *  创建自己的线程池
 *  JDK 提供的线程池及使用场景
    
     *  newFixedThreadPool
     *  newSingleThreadExecutor
     *  newCachedThreadPool
     *  newScheduledThreadPool
 *  两种提交任务的方法
    
     *  execute
     *  submit
 *  关闭线程池
 *  如何合理地选择或者配置
 *  总结
 *  Thanks

# 什么是线程池 #

线程池的概念大家应该都很清楚，帮我们重复管理线程，避免创建大量的线程增加开销。

除了降低开销以外，线程池也可以提高响应速度，了解点 JVM 的同学可能知道，一个对象的创建大概需要经过以下几步：

1.  检查对应的类是否已经被加载、解析和初始化
2.  类加载后，为新生对象分配内存
3.  将分配到的内存空间初始为 0
4.  对对象进行关键信息的设置，比如对象的哈希码等
5.  然后执行 init 方法初始化对象

创建一个对象的开销需要经过这么多步，也是需要时间的嘛，那可以复用已经创建好的线程的线程池，自然也在提高响应速度上做了贡献。

# 线程池的处理流程 #

创建线程池需要使用 `ThreadPoolExecutor` 类，它的构造函数参数如下：

public ThreadPoolExecutor(int corePoolSize,    //核心线程的数量
                              int maximumPoolSize,    //最大线程数量
                              long keepAliveTime,    //超出核心线程数量以外的线程空余存活时间
                              TimeUnit unit,    //存活时间的单位
                              BlockingQueue<Runnable> workQueue,    //保存待执行任务的队列
                              ThreadFactory threadFactory,    //创建新线程使用的工厂
                              RejectedExecutionHandler handler // 当任务无法执行时的处理器
                              ) {...}

参数介绍如注释所示，要了解这些参数左右着什么，就需要了解线程池具体的执行方法`ThreadPoolExecutor.execute`:

public void execute(Runnable command) {
        if (command == null)
            throw new NullPointerException();
    
        int c = ctl.get();
        //1.当前池中线程比核心数少，新建一个线程执行任务
        if (workerCountOf(c) < corePoolSize) {   
            if (addWorker(command, true))
                return;
            c = ctl.get();
        }
        //2.核心池已满，但任务队列未满，添加到队列中
        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);
        }
        //3.核心池已满，队列已满，试着创建一个新线程
        else if (!addWorker(command, false))
            reject(command);    //如果创建新线程失败了，说明线程池被关闭或者线程池完全满了，拒绝任务
    }

可以看到，线程池处理一个任务主要分三步处理，代码注释里已经介绍了，我再用通俗易懂的例子解释一下：

（线程比作员工，线程池比作一个团队，核心池比作团队中核心团队员工数，核心池外的比作外包员工）

1.  有了新需求，先看核心员工数量超没超出最大核心员工数，还有名额的话就新招一个核心员工来做  
    
    
     *  需要获取全局锁
2.  核心员工已经最多了，HR 不给批 HC 了，那这个需求只好攒着，放到待完成任务列表吧
3.  如果列表已经堆满了，核心员工基本没机会搞完这么多任务了，那就找个外包吧  
    
    
     *  需要获取全局锁
4.  如果核心员工 + 外包员工的数量已经是团队最多能承受人数了，没办法，这个需求接不了了

结合这张图，这回流程你明白了吗？

![这里写图片描述][SouthEast]

由于 1 和 3 新建线程时需要获取全局锁，这将严重影响性能。因此 `ThreadPoolExecutor` 这样的处理流程是为了在执行 `execute()` 方法时尽量少地执行 1 和 3，多执行 2。

> 在 `ThreadPoolExecutor` 完成预热后（当前线程数不少于核心线程数），几乎所有的 `execute()` 都是在执行步骤 2。

前面提到的 `ThreadPoolExecutor` 构造函数的参数，分别影响以下内容：

*  `corePoolSize`：核心线程池数量  
    
    
     *  在线程数少于核心数量时，有新任务进来就新建一个线程，即使有的线程没事干
     *  等超出核心数量后，就不会新建线程了，空闲的线程就得去任务队列里取任务执行了
 *  `maximumPoolSize`：最大线程数量  
    
    
     *  包括核心线程池数量 + 核心以外的数量
     *  如果任务队列满了，并且池中线程数小于最大线程数，会再创建新的线程执行任务
 *  `keepAliveTime`：核心池以外的线程存活时间，即没有任务的外包的存活时间  
    
    
     *  如果给线程池设置 `allowCoreThreadTimeOut(true)`，则核心线程在空闲时头上也会响起死亡的倒计时
     *  如果任务是多而容易执行的，可以调大这个参数，那样线程就可以在存活的时间里有更大可能接受新任务
 *  `workQueue`：保存待执行任务的阻塞队列  
    
    
     *  不同的任务类型有不同的选择，下一小节介绍
 *  `threadFactory`：每个线程创建的地方  
    
    
     *  可以给线程起个好听的名字，设置个优先级啥的
 *  `handler`：饱和策略，大家都很忙，咋办呢，有四种策略  
    
    
     *  `CallerRunsPolicy`：只要线程池没关闭，就直接用调用者所在线程来运行任务
     *  `AbortPolicy`：直接抛出 `RejectedExecutionException` 异常
     *  `DiscardPolicy`：悄悄把任务放生，不做了
     *  `DiscardOldestPolicy`：把队列里待最久的那个任务扔了，然后再调用 `execute()` 试试看能行不
     *  我们也可以实现自己的 `RejectedExecutionHandler` 接口自定义策略，比如如记录日志什么的

# 保存待执行任务的阻塞队列 #

当线程池中的核心线程数已满时，任务就要保存到队列中了。

线程池中使用的队列是 `BlockingQueue` 接口，常用的实现有如下几种：

*  ArrayBlockingQueue：基于数组、有界，按 FIFO（先进先出）原则对元素进行排序
 *  LinkedBlockingQueue：基于链表，按FIFO （先进先出） 排序元素  
    
    
     *  吞吐量通常要高于 ArrayBlockingQueue
     *  Executors.newFixedThreadPool() 使用了这个队列
 *  SynchronousQueue：不存储元素的阻塞队列  
    
    
     *  每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态
     *  吞吐量通常要高于 LinkedBlockingQueue
     *  Executors.newCachedThreadPool使用了这个队列
 *  PriorityBlockingQueue：具有优先级的、无限阻塞队列

> 关于阻塞队列的详细介绍请看这 2 篇：  
> [Java 阻塞队列源码分析（上）][Java]  
> [Java 阻塞队列源码分析（下）][Java 1]

# 创建自己的线程池 #

了解上面的内容后，我们就可以创建自己的线程池了。

①先定义线程池的几个关键属性的值：

private static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 2; // 核心线程数为 CPU 数＊2
    private static final int MAXIMUM_POOL_SIZE = 64;    // 线程池最大线程数
    private static final int KEEP_ALIVE_TIME = 1;    // 保持存活时间 1秒

*  设置核心池的数量为 CPU 数的两倍，一般是 4、8，好点的 16 个线程
 *  最大线程数设置为 64
 *  空闲线程的存活时间设置为 1 秒

②然后根据处理的任务类型选择不同的阻塞队列

如果是要求高吞吐量的，可以使用 `SynchronousQueue` 队列；如果对执行顺序有要求，可以使用 `PriorityBlockingQueue`；如果最大积攒的待做任务有上限，可以使用 `LinkedBlockingQueue`。

private final BlockingQueue<Runnable> mWorkQueue = new LinkedBlockingQueue<>(128);

③然后创建自己的 `ThreadFactory`

在其中为每个线程设置个名称：

private final ThreadFactory DEFAULT_THREAD_FACTORY = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);
    
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r, TAG + " #" + mCount.getAndIncrement());
            thread.setPriority(Thread.NORM_PRIORITY);
            return thread;
        }
    };

④然后就可以创建线程池了

private ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_TIME,
            TimeUnit.SECONDS, mWorkQueue, DEFAULT_THREAD_FACTORY,
            new ThreadPoolExecutor.DiscardOldestPolicy());

这里我们选择的饱和策略为 `DiscardOldestPolicy`，你可以可以创建自己的。

⑤完整代码：

public class ThreadPoolManager {
        
        private final String TAG = this.getClass().getSimpleName();
        private static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 2; // 核心线程数为 CPU数＊2
        private static final int MAXIMUM_POOL_SIZE = 64;    // 线程队列最大线程数
        private static final int KEEP_ALIVE_TIME = 1;    // 保持存活时间 1秒
    
        private final BlockingQueue<Runnable> mWorkQueue = new LinkedBlockingQueue<>(128);
    
        private final ThreadFactory DEFAULT_THREAD_FACTORY = new ThreadFactory() {
            private final AtomicInteger mCount = new AtomicInteger(1);
    
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r, TAG + " #" + mCount.getAndIncrement());
                thread.setPriority(Thread.NORM_PRIORITY);
                return thread;
            }
        };
    
        private ThreadPoolExecutor mExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_TIME,
                TimeUnit.SECONDS, mWorkQueue, DEFAULT_THREAD_FACTORY,
                new ThreadPoolExecutor.DiscardOldestPolicy());
    
        private static volatile ThreadPoolManager mInstance = new ThreadPoolManager();
    
        public static ThreadPoolManager getInstance() {
            return mInstance;
        }
    
        public void addTask(Runnable runnable) {
            mExecutor.execute(runnable);
        }
    
        @Deprecated
        public void shutdownNow() {
            mExecutor.shutdownNow();
        }
    }

这样我们就有了自己的线程池。

# JDK 提供的线程池及使用场景 #

JDK 为我们内置了五种常见线程池的实现，均可以使用 `Executors` 工厂类创建。

## 1.newFixedThreadPool ##

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

**不招外包，有固定数量核心成员的正常互联网团队。**

可以看到，`FixedThreadPool` 的核心线程数和最大线程数都是指定值，也就是说当线程池中的线程数超过核心线程数后，任务都会被放到阻塞队列中。

此外 `keepAliveTime` 为 0，也就是多余的空余线程会被立即终止（由于这里没有多余线程，这个参数也没什么意义了）。

而这里选用的阻塞队列是 `LinkedBlockingQueue`，使用的是默认容量 `Integer.MAX_VALUE`，相当于没有上限。

因此这个线程池执行任务的流程如下：

1.  线程数少于核心线程数，也就是设置的线程数时，新建线程执行任务
2.  线程数等于核心线程数后，将任务加入阻塞队列  
    
    
     *  由于队列容量非常大，可以一直加加加
3.  执行完任务的线程反复去队列中取任务执行

**`FixedThreadPool` 用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。**

## 2.newSingleThreadExecutor ##

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

**不招外包，只有一个核心成员的创业团队。**

从参数可以看出来，`SingleThreadExecutor` 相当于特殊的 `FixedThreadPool`，它的执行流程如下：

1.  线程池中没有线程时，新建一个线程执行任务
2.  有一个线程以后，将任务加入阻塞队列，不停加加加
3.  唯一的这一个线程不停地去队列里取任务执行

听起来很可怜的样子 - -。

**`SingleThreadExecutor` 用于串行执行任务的场景，每个任务必须按顺序执行，不需要并发执行。**

## 3.newCachedThreadPool ##

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

**全部外包，没活最多待 60 秒的外包团队。**

可以看到，`CachedThreadPool` 没有核心线程，非核心线程数无上限，也就是全部使用外包，但是每个外包空闲的时间只有 60 秒，超过后就会被回收。

`CachedThreadPool` 使用的队列是 `SynchronousQueue`，这个队列的作用就是传递任务，并不会保存。

因此当提交任务的速度大于处理任务的速度时，每次提交一个任务，就会创建一个线程。极端情况下会创建过多的线程，耗尽 CPU 和内存资源。

它的执行流程如下：

1.  没有核心线程，直接向 `SynchronousQueue` 中提交任务
2.  如果有空闲线程，就去取出任务执行；如果没有空闲线程，就新建一个
3.  执行完任务的线程有 60 秒生存时间，如果在这个时间内可以接到新任务，就可以继续活下去，否则就拜拜

由于空闲 60 秒的线程会被终止，长时间保持空闲的 `CachedThreadPool` 不会占用任何资源。

**`CachedThreadPool` 用于并发执行大量短期的小任务，或者是负载较轻的服务器。**

## 4.newScheduledThreadPool ##

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }
    public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }
    private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;

**定期维护的 2B 业务团队，核心与外包成员都有。**

`ScheduledThreadPoolExecutor` 继承自 `ThreadPoolExecutor`， 最多线程数为 `Integer.MAX_VALUE` ，使用 `DelayedWorkQueue` 作为任务队列。

`ScheduledThreadPoolExecutor` 添加任务和执行任务的机制与`ThreadPoolExecutor` 有所不同。

`ScheduledThreadPoolExecutor` 添加任务提供了另外两个方法：

*  `scheduleAtFixedRate()` ：按某种速率周期执行
 *  `scheduleWithFixedDelay()`：在某个延迟后执行

它俩的代码如下：

public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (period <= 0L)
            throw new IllegalArgumentException();
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          unit.toNanos(period),
                                          sequencer.getAndIncrement());
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit) {
        if (command == null || unit == null)
            throw new NullPointerException();
        if (delay <= 0L)
            throw new IllegalArgumentException();
        ScheduledFutureTask<Void> sft =
            new ScheduledFutureTask<Void>(command,
                                          null,
                                          triggerTime(initialDelay, unit),
                                          -unit.toNanos(delay),
                                          sequencer.getAndIncrement());
        RunnableScheduledFuture<Void> t = decorateTask(command, sft);
        sft.outerTask = t;
        delayedExecute(t);
        return t;
    }

可以看到，这两种方法都是创建了一个 `ScheduledFutureTask` 对象，调用 `decorateTask()` 方法转成 `RunnableScheduledFuture` 对象，然后添加到队列中。

看下 `ScheduledFutureTask` 的主要属性：

private class ScheduledFutureTask<V>
            extends FutureTask<V> implements RunnableScheduledFuture<V> {
        
    
        //添加到队列中的顺序
        private final long sequenceNumber;
        //何时执行这个任务
        private volatile long time;
        //执行的间隔周期
        private final long period;
        //实际被添加到队列中的 task
        RunnableScheduledFuture<V> outerTask = this;
        //在 delay queue 中的索引，便于取消时快速查找
        int heapIndex;
        //...
    }

`DelayQueue` 中封装了一个优先级队列，这个队列会对队列中的 `ScheduledFutureTask` 进行排序，两个任务的执行 time 不同时，time 小的先执行；否则比较添加到队列中的顺序 sequenceNumber ，先提交的先执行。

`ScheduledThreadPoolExecutor` 的执行流程如下：

1.  调用上面两个方法添加一个任务
2.  线程池中的线程从 DelayQueue 中取任务
3.  然后执行任务

具体执行任务的步骤也比较复杂：

1.  线程从 DelayQueue 中获取 time 大于等于当前时间的 ScheduledFutureTask  
    
    
     *  `DelayQueue.take()`
2.  执行完后修改这个 task 的 time 为下次被执行的时间
3.  然后再把这个 task 放回队列中  
    
    
     *  `DelayQueue.add()`

**`ScheduledThreadPoolExecutor` 用于需要多个后台线程执行周期任务，同时需要限制线程数量的场景。**

# 两种提交任务的方法 #

`ExecutorService` 提供了两种提交任务的方法：

1.  `execute()`：提交不需要返回值的任务
2.  `submit()`：提交需要返回值的任务

## execute ##

void execute(Runnable command);

`execute()` 的参数是一个 Runnable，也没有返回值。因此提交后无法判断该任务是否被线程池执行成功。

ExecutorService executor = Executors.newCachedThreadPool();
    executor.execute(new Runnable() {
        @Override
        public void run() {
            //do something
        }
    });

## submit ##

<T> Future<T> submit(Callable<T> task);
    <T> Future<T> submit(Runnable task, T result);
    Future<?> submit(Runnable task);

`submit()` 有三种重载，参数可以是 `Callable` 也可以是 `Runnable`。

同时它会返回一个 `Funture` 对象，通过它我们可以判断任务是否执行成功。

获得执行结果调用 `Future.get()` 方法，这个方法会阻塞当前线程直到任务完成。

提交一个 `Callable` 任务时，需要使用 `FutureTask` 包一层：

FutureTask futureTask = new FutureTask(new Callable<String>() {    //创建 Callable 任务
        @Override
        public String call() throws Exception {
            String result = "";
            //do something
            return result;
        }
    });
    Future<?> submit = executor.submit(futureTask);    //提交到线程池
    try {
        Object result = submit.get();    //获取结果
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

# 关闭线程池 #

线程池即使不执行任务也会占用一些资源，所以在我们要退出任务时最好关闭线程池。

有两个方法关闭线程池：

1.`` `shutdown()``

public void shutdown() {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                checkShutdownAccess();  //获取权限
                advanceRunState(SHUTDOWN);  //修改运行状态
                interruptIdleWorkers();  //遍历停止未开启的线程
                onShutdown(); // 目前空实现
            } finally {
                mainLock.unlock();
            }
            tryTerminate();
        }
        private void interruptIdleWorkers(boolean onlyOne) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                for (Worker w : workers) {  //遍历所有线程
                    Thread t = w.thread;
                    //多了一个条件w.tryLock()，表示拿到锁后就中断
                    if (!t.isInterrupted() && w.tryLock()) {
                        try {
                            t.interrupt();
                        } catch (SecurityException ignore) {
                        } finally {
                            w.unlock();
                        }
                    }
                    if (onlyOne)
                        break;
                }
            } finally {
                mainLock.unlock();
            }
        }

将线程池的状态设置为 `SHUTDOWN`，然后中断所有 **没有执行** 的线程，无法再添加线程。

2.`shutdownNow()`

public List<Runnable> shutdownNow() {
            List<Runnable> tasks;
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                checkShutdownAccess();
                advanceRunState(STOP);  //修改运行状态
                interruptWorkers();     //中断所有
                tasks = drainQueue();
            } finally {
                mainLock.unlock();
            }
            tryTerminate();
            return tasks;
        }
    
        private void interruptWorkers() {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                for (Worker w : workers)  //中断全部线程，不管是否在执行
                    w.interruptIfStarted();
            } finally {
                mainLock.unlock();
            }
        }

将线程池设置为 `STOP`，然后尝试停止 **所有线程**，并返回等待执行任务的列表。

它们的不同点是：`shutdown()` 只结束未执行的任务；`shutdownNow()` 结束全部。

共同点是：都是通过遍历线程池中的线程，逐个调用 `Thread.interrup()` 来中断线程，所以一些无法响应中断的任务可能永远无法停止（比如 `Runnable`）。

# 如何合理地选择或者配置 #

了解 JDK 提供的几种线程池实现，在实际开发中如何选择呢？

根据任务类型决定。  
前面已经介绍了，这里再小节一下：

*  **`CachedThreadPool` 用于并发执行大量短期的小任务，或者是负载较轻的服务器。**
 *  **`FixedThreadPool` 用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量。**
 *  **`SingleThreadExecutor` 用于串行执行任务的场景，每个任务必须按顺序执行，不需要并发执行。**
 *  **`ScheduledThreadPoolExecutor` 用于需要多个后台线程执行周期任务，同时需要限制线程数量的场景。**

自定义线程池时，如果任务是 CPU 密集型（需要进行大量计算、处理），则应该配置尽量少的线程，比如 CPU 个数 + 1，这样可以避免出现每个线程都需要使用很长时间但是有太多线程争抢资源的情况；  
如果任务是 IO密集型（主要时间都在 I/O，CPU 空闲时间比较多），则应该配置多一些线程，比如 CPU 数的两倍，这样可以更高地压榨 CPU。

**为了错误避免创建过多线程导致系统奔溃，建议使用有界队列。**因为它在无法添加更多任务时会拒绝任务，这样可以提前预警，避免影响整个系统。

执行时间、顺序有要求的话可以选择优先级队列，同时也要保证低优先级的任务有机会被执行。

# 总结 #

这篇文章简单介绍了 Java 中线程池的工作原理和一些常见线程池的使用，在实际开发中最好使用线程池来统一管理异步任务，而不是直接 new 一个线程执行任务。

# Thanks #

《Java 并发编程的艺术》  
[https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ThreadPoolExecutor.html][https_docs.oracle.com_javase_8_docs_api_java_util_concurrent_ThreadPoolExecutor.html]  
[Java多线程（2）：使用线程池][Java_2]  
[http://www.infoq.com/cn/articles/java-threadPool/][http_www.infoq.com_cn_articles_java-threadPool]

[_1_ Thread]: http://blog.csdn.net/u011240877/article/details/57202704
[_2]: http://blog.csdn.net/u011240877/article/details/58756137
[SouthEast]: /images/20220614/36a25f7c916d424ead6d79c1604dd8e9.png
[Java]: http://blog.csdn.net/u011240877/article/details/73612930
[Java 1]: http://blog.csdn.net/u011240877/article/details/73742407
[https_docs.oracle.com_javase_8_docs_api_java_util_concurrent_ThreadPoolExecutor.html]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ThreadPoolExecutor.html
[Java_2]: https://segmentfault.com/a/1190000007925310
[http_www.infoq.com_cn_articles_java-threadPool]: http://www.infoq.com/cn/articles/java-threadPool/