彻底搞懂 Java 线程池，干啥都不再发憷

作为 Java 程序员， 无论是技术面试、 项目 研发或者是学习 框架源码，不彻底掌握 Java 多线程的知识，做不到心中有数，干啥都没底气，尤其是技术深究时往往略显 发憷 。

没事，跟随小猿的脚步，一起嗨起来！言归正传，书接上篇，继续探索多线程相关的知识。

1

 回顾：创建线程的几种方式？   

在 Java 的世界里，大家最熟悉的线程的创建方式， 莫过于 Java 提供的 Thread 类和 Runnable 接口 。

核心知识点（一）：继承 Thread 类 VS 实现 Runnable 接口的区别？

从  J D K1.5  开始 ， Java 提供了  Callable 接口，提供另一种创建线程的方式。

核心知识点（二）： 实现 Callable 接口创建线程，有啥独特？

使用实现 Callable 接口的方式创建的线程，相对于继承 Thread 类和实现 Runnable 接口来创建线程的方式而言， 可以获取到线程执行的返回值、以及是否执行完成等信息。

2

  思考：无限制的创建线程，会带来什么问题？    

在项目开发中，为了提高系统的吞吐量和性能，很多同学都会随手写出如下最简单的线程创建代码。

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("我是一个孤独的线程");
        // do something
    }
}).start();

有的同学，会采用 Lambda 表达式，写出如下稍显高 B 格的代码。

new Thread(() -> System.out.println("我是一个孤独的线程")).start();

在简单的应用中，上面的代码没有太大的问题。但是如果在业务量较大，可能要开启很多线程来处理，而当线程数量过大时，反而会耗尽 CPU 和内存资源，如果处理不当，可能会导致 Out of Memory 异常。

写段代码，简单示意一下内存溢出。

// 待通知的消息
List<String> notifyMsgList = new ArrayList<String>(10000);
for (int i = 0; i < 10000; i++) {
    notifyMsgList.add("发工资啦" + i);
}

// 通知用户
for (String msg : notifyMsgList) {
    // 多线程发送
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("通知：" + msg);
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

程序跑起来，大概率会出现内存溢出的异常。

java.lang.OutOfMemoryError: unable to create new native thread

贴一效果图，真的不诳你。

这么看，线（劲）程（酒）虽好，不能贪多（杯）呀。在生产环境中，线程的数量必须要进行控制，不然盲目的创建大量线程会对系统性能造成伤害，甚至会导致内存溢出，拖垮应用。

那该怎么办？这就很有必要引入线程池啦。

3

  Executor 框架入门：别造轮子啦，JDK 都给你提供啦！    

线程池的基本功能就是进行线程的复用，当系统接受一个提交的任务，需要一个线程时，并不立即去创建线程，而是先去线程池查找是否有空余的线程，若有，则直接使用线程池中的线程进行工作，若没有，再去创建新的线程。待任务完成后，也销毁线程，而是将线程放入线程池的空闲对列，等待下次使用。

在线程频繁调度的场景中， JDK1.5 以前， 攻城狮必须手动打造线程池，来节约系统开销；而从 JDK1.5 开始，Java 提供了一个 Excutors 工厂类来生产线程池，可以帮助攻城狮有效的进行线程控制 。

核心知识点（一）： Excutors 工厂类的主要方法有哪些？

public static ExecutorService newFixedThreadPool(int nThreads)
public static ExecutorService newSingleThreadExecutor()
public static ExecutorService newCachedThreadPool()
public static ScheduledExecutorService newSingleThreadScheduledExecutor()
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)

上面列举的方法中，分别返回了不同工作特性的线程池，下面简单介绍一下每个方法。

1. newFixedThreadPool(int nThreads)

用途： 创建一个可重用的、具有固定线程数的线程池。

备注： 该线程池中的线程数量始终不变，当有一个新的任务提交时，线程中若有空闲线程，则立即执行，若没有则空闲线程，新的任务会被暂存在一个任务队列中，待有线程空闲时，便处理在任务队列中的任务。

2. newSingleThreadExecutor()

用途： 创建一个只有一个线程的线程池，相当于 newFixedThreadPool(int nThreads) 方法调用时传入的参数为 1。

备注： 该线程池中的线程数量为 1。

3. newCachedThreadPool()

用途： 创建一个具有缓存功能的线程池，系统根据需要创建线程，这些线程会被缓存在线程池中。

备注： 该线程池中的线程数量不确定，但若有空闲线程可以复用，则会优先使用可复用的线程，若所有线程均在工作，又有新的任务提交，则会创建新的线程处理任务。所有线程在当前任务执行完毕后，将返回线程池进行复用。

4. newSingleThreadScheduledExecutor()

用途： 创建只有一条线程的线程池，它可以在指定延迟后执行线程任务。

备注： 线程池大小为 1，并且可以在 固定的延时之后执行或者周期性执行某个任务 。

5. newScheduledThreadPool(int corePoolSize)

用途： 创建具有指定线程数的线程池，它可以在指定延迟后执行线程任务。

备注： corePoolSize 指池中所保存的线程数，即使线程是空闲的，也被保存在线程池内。

上面列举了 Excutors 类 中的一些方法 ，仔细去看，会发现 前 三个返回一个 ExcutorService 对象，而后两个方法返回  ScheduledExecutorService 对象。

核心知识点（二）： ExcutorService 与 ScheduledExecutorService 啥区别？

走进源码，从方法定义上着重分析一下区别。

首先 截取 ExcutorService  的部分方法定义， 重点关注 submit 重载 的方法。

上面截图释义：

• 标注 1 的方法释义： 将一个 Callable 对象提交给指定的线程池，Future 代表 Callable 对象里 call 方法的返回值。

• 标注 2 的方法释义：将一个 Runnable 对象提交给指定的线程池，result 显示指定线程执行结束后的返回值，所以 Future 对象将在 run 方法执行结束后返回 result。

• 标注 3 的方法释义： 将一个 Runnable  对象提交给 指定的线程池， 其中 Future 对象是 Runnable 任务的返回值（但是 run方法没有返回值，不过可以借用 Future 的方法来获取任务执行的状态）。

了解完 ExcutorService ，那么来看看  ScheduledExecutorService 的方法定义。

上面截图释义：

• 标注 1 的方法与标注 2 的方法， 主要功能 是在 指定  delay  延迟后执行 任务。 区别是入参一个接受 Runnable 任务，一个接受 Callable 任务。

• 标注 3 的方法， 功能是在 initialDelay 后开始执行 command，而且以固定频率重复执行，依次是 initialDelay  + period、 initialDelay  + 2*period ... 。

• 标注 4 的方法 ，功能是在  initialDelay 后开始执行 command ，随后在每一次执行终止和下一次执行开始之前都存在给定的延迟，如果任务执行时遇到异常，就会取消后续执行。

了解完方法定义，区别就很简单了：

• ExcutorService 代表一个线程池，可以执行 Runnable 对象或者 Callable 对象所代表的线程；

• ScheduledExecutorService  是  ExcutorService  的子类，可以在指定延迟后执行线程任务或者周期性的执行某个任务。

4

 Executor 框架使用：说的再多，都不如写一行代码！   

还是以开篇发工资的场景为例， 若借 助 线程池来实现 ，假设允许开启 10 个线程来进行发工资（理解成 10 个人同时干活就行），代码改造如下。

// 待通知的消息
List<String> notifyMsgList = new ArrayList<String>(10000);
for (int i = 0; i < 10000; i++) {
    notifyMsgList.add("发工资啦" + i);
}

// 1. 调用 Excutors 类的静态工厂方法创建一个 ExcutorService 对象（线程池）；
ExecutorService executorService = Executors.newFixedThreadPool(100);
// 通知用户
for (String msg : notifyMsgList) {
    // 2. 创建 Runnable 实现类或者 Callable 实现类的实例，作为线程执行任务。
    // 3. 调用 ExcutorService 对象的 submit 方法来提交 Runnable 实例或 Callable 实例。
    executorService.submit(new Runnable() {
        @Override
        public void run() {
            System.out.println("通知：" + msg);
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}

//4. 调用 ExcutorService 对象的 shutdown 方法来关闭线程池。
executorService.shutdown();

程序跑起来，很清晰的能看出有 10 个线程同时在处理任务。

好了，到这简单总结一下，使用线程池来编程时的步骤（仔细看代码注释就行啦） 。

• 调用 Excutors 类的静态工厂方法创建一个 ExcutorService 对象（线程池）；

• 创建 Runnable 实现类或者 Callable 实现类的实例，作为线程执行任务；

• 调用 ExcutorService 对象的 submit 方法来提交 Runnable 实例或 Callable 实例；

• 调用 ExcutorService 对象的 shutdown 方法来关闭线程池。

既然提到了关闭线程池的 shutdown 方法，那 再抛一知识 点 ： shutdown 与 shutdownNow 的区别 是啥？

写段程序很容易发现结论，还是借助上面发工资通知的代码，把通知的消息改为 11，把线程数改为 10。

首先 调用  shutdown 方法关闭线程池 ，代码 如下。

// 待通知的消息
List<String> notifyMsgList = new ArrayList<String>(10000);
for (int i = 0; i < 11; i++) {
    notifyMsgList.add("发工资啦" + i);
}

// 1. 调用 Excutors 类的静态工厂方法创建一个 ExcutorService 对象（线程池）；
ExecutorService executorService = Executors.newFixedThreadPool(10);
// 通知用户
for (String msg : notifyMsgList) {
    // 2. 创建 Runnable 实现类或者 Callable 实现类的实例，作为线程执行任务。
    // 3. 调用 ExcutorService 对象的 submit 方法来提交 Runnable 实例或 Callable 实例。
    executorService.submit(new Runnable() {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName()+ "-->通知：" + msg);
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
}

//4. 调用 ExcutorService 对象的 shutdown 方法来关闭线程池。
executorService.shutdown();

输出截图（执行完了，才优雅的终止） ：

接着改造代码，调用  shutdownNow 方法来关闭线程池 ，代码 如下。

//4. 调用 ExcutorService 对象的 shutdownNow 方法来关闭线程池。
List<Runnable> tasks = executorService.shutdownNow();
System.out.println(tasks);

输出截图 ：

结论：

• 当程序调用 shutdown 方法时，线程池将不再接受新的任务，但会将以前所有已提交的任务执行完成（优雅停服的背后支撑者）；

• 当调用 shutdownNow 方法来关闭线程池时，该方法会试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。

5

寄语写最后 

本次，本次主要回顾了创建线程的方式，并对 JDK 对任务执行框架 Excutor 进行初步讲解，后续会带你一起走进这个框架背后隐藏的  ThreadPoolExecutor 类，一起去探寻线程池背后的奥秘。

好了，本次就谈到这里， 一起聊技术、谈业务、喷架构，少走弯路，不踩大坑。 会持续输出原创精彩分享，敬请期待！

推荐阅读：

Java程序跑的快，全要靠线程带

fastjson的这些坑，你误入了没？

真实|技术人员该如何站好最后一班岗？

Java 8 的这些特性，你知道吗？

改掉这些坏习惯，还怕写不出健壮的代码？ （一）

改掉这些坏习惯，还怕写不出优雅的代码？ （二）

改掉这些坏习惯，还怕写不出优雅的代码？ （三）

改掉这些坏习惯，还怕写不出健壮的代码？ （四）

改掉这些坏习惯，还怕写不出精简的代码？ （五）

改掉这些坏习惯，还怕写不出精简的代码？ （六）