当前位置：首页 > news >正文

多线程代码案例-4 线程池

news 来源：原创 2025/7/27 19:01:02

1、引入

池是一个非常重要的概念，我们有常量池，数据库连接池，线程池，进程池，内存池……

池的作用：

1、提前把要用的对象准备好

2、用完的对象也不立即释放，先留着以备下次使用，提高效率。

一开始讲过，进程能够解决并发编程问题，但是因为频繁创建和销毁进程，需要耗费大量的空间、时间，成本太高了，所以我们引进了轻量级进程——线程。

但是如果创建和销毁线程的频率进一步提高，此时线程创建和销毁的开销，也不能忽略了。（抛开剂量谈毒性，都是耍流氓），因此我们需要想办法，优化此处线程创建和销毁的效率。

1、引入轻量级线程——纤程/ 协程（Java21引入的虚拟线程就是这个东西）。协程本质，是程序员在用户态的代码中进行调度，而不是靠内核调度器调度，这就节省了很多调度上的开销。

2、线程池：把要使用的线程提前创建好，用完了也不直接释放，而是以备下次使用。这样就节省了线程创建/销毁的开销。在这个过程中，没有频繁创建销毁线程，只是从线程池里面，取线程使用，用完了就还给线程池。

那为什么，从线程池里面取线程，就比从系统申请更加高效呢？

举个例子：还是银行的例子，柜台里面，相当于内核态，大堂相当于用户态。

当我们要办理业务，需要一个身份证复印件的时候，我们并没有带，此时，业务员说我们有两个途径解决：

1、自己拿着身份证，去自助复印机上打印即可（纯用户态代码）

2、把身份证交给业务员，他拿着身份证帮你去复印。（业务员拿到我们的身份证之后，就消失在我们的视野之中了，此时我们不知道他要花费多长时间，也不知道他要做哪些事情，我们唯一能做的，就是等……）

结论：如果一个工作，靠用户自己就能完成，就更加可控，更加高效。从线程池里面取线程，是纯用户态代码，更加可控，更加高效。

如果一个工作，用户拜托业务员完成，就不可控，更低效。通过系统申请创建线程是需要内核来完成的，不可控，更低效。

2、标准库中的线程池

我们可以在Java官方文档中，找到java.util.concurrent这个包，在下面的Classes中就可以找到ThreadPoolExecutor，往下翻就可以找到构造方法，有四种：

我们只需要关注最后一个就可以（最后一种参数最全）。

2.1 构造方法参数

1、int corePoolSize

表示的是核心线程数（一个线程池中，最少得有多少个线程）。

2、int maximumPoolSize

表示的最大线程数（一个线程池中，最多能有多少个线程）。

注意：标准库提供的线程池，持有的线程的个数，并非是一成不变的，会根据当前任务量，自适应线程的个数。（任务非常多，就多搞几个线程；任务比较少，就少搞几个线程）。

举个例子：假设一个公司，里面有10个员工（正式签劳动合同的员工）。当公司业务非常繁忙的时候，10个人就干不过来了，就需要招聘……一个成本比较低的做法：招聘实习生（非正式员工），比如可以再招聘5个实习生（廉价劳动力）

过了一段时间，公司没那么忙了，大家都闲下来开始摸鱼了，10个正式员工，是不能随便裁掉的，但是这5个实习生，是可以随便裁的。把这5个实习生裁掉，当前这10个正式员工也就没有那么空闲了，整体的成本也降低了。

如果过了一段时间，公司业务又多了起来，10个人又忙不过来了，此时再重新招几个实习生进来就好了。

通过实习生来应对突发的峰值！！！

此时，这10个正式员工就是核心线程数，10正式员工+5实习生就是最大线程数了。

3、long keepAliveTime

表示的是保持存活时间，实习生线程空闲时间超过了这个时间限制，就会被销毁掉。实习生线程被销毁掉之后，就没有了，在未来的某一天，线程池还会重新招聘实习生，但已经不是之前那个了。

4、TimeUnit unit

表示的是时间单位（s、min、ms、hour），即指定保持存活时间的时间单位。

5、BlockingQueue<Runnable>workQueue

和定时器类似的阻塞队列，用来存放等待执行的任务。当核心线程都在忙碌的时候，新任务就会放入这个队列中排队等待。Runnable用来描述任务的主体。也可以设置为PriorityBlockingQueue，使当前阻塞队列带有优先级。

6、ThreadFactory threadFactory

表示线程工厂。

工厂模式，和单例模式一样，也是一种常见的设计模式。通过专门的“工厂类/工厂对象”来创建指定的对象，本质上是给Java语法填坑的：

举个例子：

我们会发现，上面的代码，无法通过编译，因为这两个构造方法无法构成重载。

构成重载的条件：

1、方法名字相同

2、新参的个数/类型不同

上面的代码，不符合第二个条件，无法通过编译。为了解决上述问题，就引入了“工厂模式”，使用普通的方法来创建对象，相当于把构造方法封装了一层。

如果把工厂方法放到一个其他的类里面，这个类就叫做“工厂类 ”。

总结：通过静态方法封装new操作，在main方法中无需实例化对象，在方法内部设定不同的属性完成对对象初始化，构造对象的过程，就是工厂模式。

回来看我们的参数:ThreadFactory threadfactory通过这个工厂类，来创建线程对象（Thread对象）在这个类里面提供了方法（也不一定非得是静态的），这些方法封装了newThread操作，并且给Thread设置一些属性，就构成了ThreadFactory（线程工厂）。

7、RejectExecutionHandle handler

这个是其中最重要的参数!!!

这个表示的是拒绝策略。在线程池中，有一个阻塞队列，它能够容纳的元素是有上限的。当任务队列已经满了的时候，如果继续往队列里面添加元素，那么线程池会怎么办呢？这就需要拒绝策略来发挥作用了。

这是官方文档给出的四种拒绝策略:

1、直接抛出异常:当继续添加任务的时候，系统会直接抛出异常，进入“撂挑子”状态。此时，无论是新任务还是旧任务，都停止执行。

2、由调用者执行：新任务由添加任务的线程负责执行，而非线程池执行。

3、丢弃最老的任务：系统会舍弃最老的任务，然后去执行新添加的任务。

4、丢弃最新的任务：新的任务会直接被抛弃，不再执行。不会调用线程，线程池也不会执行该任务。

3、Executor工厂类

ThreadPoolExecutor本身使用起来是比较复杂的，因此Java标准库还提供了另外一个封装起来的版本——Excutors工厂类。通过这个类来创建出不同的线程池对象（在内部就把ThreadPoolExecutor创建好了并且设置了不同的参数）：可以看到Executors这个工厂类中由许多不同的线程池：

newSingleThreadExecutor（）：只包含单个线程的线程池。

newScheduleThreadPool（）：类似于定时器，也能延时执行任务。

newCachThreadPool（）：是线程数目能够动态扩容的线程池。

newFixedThreadPool（）：是线程数目固定的线程池。

示例代码：

public class ThreadDemo32 {public static void main(String[] args) {ExecutorService service = Executors.newFixedThreadPool(4);//添加任务service.submit(new Runnable() {@Overridepublic void run() {System.out.println("hello world");}});}
}

打印结果如下：

ThreadPoolExecutor也是通过submit添加任务，只是构造方法不同。

那么什么时候使用Executor什么时候使用ThreadPoolExecutor呢？？？

当我们只是简单使用一个线程池的时候，就可以使用Executors，而当我们需要一个高度定制化的线程池的时候，就可以使用ThreadPoolExcutor

阿里巴巴的Java开发手册中写道：不建议使用Executors，一定要使用ThreadPoolExecutor，用ThreadPoolExecutor一切尽在掌握之中，不会出现不可控因素。这个我们可以参考，但还是要以具体公司的编程规范为准。

4、如何确定线程池的线程数量

创建线程池的时候，很多时候，需要程序员设定线程池的数量。这个数量怎么设置更合适呢？

网上很多的说法：加入CPU的逻辑核心数是N，线程数量应该是N,N+1,1.5N,2N……这些说法都是错误的。

不同的程序，需要设定的线程的数量是不同的，必须要具体问题具体分析。

我们需要进行区分，当前任务是CPU密集型的任务，还是IO密集型任务。

CPU密集型任务：这个线程池中的大部分线程都要到CPU上运行，进行计算。比如，在线程的run方法中计算1~10w种就是CPU密集型。

IO密集型任务：这个线程大部分时间都在等待IO（输入：input 输出：output），不需要到CPU上运行，比如，在run方法中，搞一个scanner，读取用户输入，就是IO密集型。

如果线程池中的所有项目都是CPU密集型的，每个线程所有的工作都要到CPU上执行的，此时，线程的数目不应该超过CPU逻辑核心数N。

如果线程池中的所有项目都是IO密集型的，每个线程的所有工作都是等待IO，CPU资源消耗非常少，此时线程的数目就可以远超过CPU逻辑核心数N。

数目的两个场景都是两种非常极端的情况，在日常开发中，一个进程中的线程，一部分是IO密集型，一部分是CPU密集型，这里的比例是不好确定的。

综上，由于程序的复杂性，很难直接对线程的数量进行估计。更合适的做法应该是：通过实验/测试的方式，找到更合适的线程数目。即尝试给线程池，设定不同的线程数目，分别进行性能测试，衡量每种线程数目下的时间开销和资源占用开销，找到两者的合适值。

5、实现一个简单的线程池

我们这里实现的线程池是固定数目的，暂时不考虑线程数目的增多和减少。

大致思路如下：

1、提供构造方法，指定创建多少个线程。

2、在构造方法中，把这些线程创建号。

3、有一个阻塞队列，持有要执行的任务。

4、提供submit方法，用来添加新的任务。

代码如下：

class MyThreadPoolExecutor{private List<Thread> threadList = new ArrayList<>();//用来保存任务的队列private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);//通过n指定创建多少个线程public MyThreadPoolExecutor(int n){for (int i = 0; i < n; i++) {Thread t = new Thread(()->{while (true) {try {//此处的take是有阻塞功能的//如果此时的队列为空，此处的take就会阻塞Runnable runnable = queue.take();//取出一个任务就执行一个任务runnable.run();} catch (InterruptedException e) {throw new RuntimeException(e);}}});t.start();threadList.add(t);}}public void submit(Runnable runnable) throws InterruptedException {queue.put(runnable);}
}

构造方法使用while（true），不断循环获取阻塞队列中的元素，并调用该元素的run方法执行这个任务。

submit方法负责把任务添加到任务队列，起到任务提交的作用。

提供这种方式，线程池能够高效地复用，减少线程创建销毁带来的开销。

测试代码：

在这个代码中我们看到i的下面有一个小小的红色波浪线：这就涉及到我们之前讲过的变量捕获了。

run这个回调函数访问当前外部作用域的变量就是变量捕获，我们之前讲过，变量捕获的值，要不是final修饰的常量值，要不就得是一个“事实final”的变量，但我们现在的i是一直变化的。

解决方法：只需在循环中将i赋值给n即可：

运行结果：

从这些结果也可以看出：线程的随即调度/抢占式执行。

完整代码：

package Thread;import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;class MyThreadPoolExecutor{private List<Thread> threadList = new ArrayList<>();//用来保存任务的队列private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(10);//通过n指定创建多少个线程public MyThreadPoolExecutor(int n){for (int i = 0; i < n; i++) {Thread t = new Thread(()->{while (true) {try {//此处的take是有阻塞功能的//如果此时的队列为空，此处的take就会阻塞Runnable runnable = queue.take();//取出一个任务就执行一个任务runnable.run();} catch (InterruptedException e) {throw new RuntimeException(e);}}});t.start();threadList.add(t);}}public void submit(Runnable runnable) throws InterruptedException {queue.put(runnable);}
}
public class ThreadDemo33 {public static void main(String[] args) throws InterruptedException {MyThreadPoolExecutor myThreadPoolExecutor = new MyThreadPoolExecutor(4);for (int i = 0; i < 1000; i++) {int n = i;myThreadPoolExecutor.submit(new Runnable() {@Overridepublic void run() {System.out.println("执行任务"+n+",当前线程为："+Thread.currentThread().getName());}});}}
}