如何设计线程池

已于 2022-03-07 20:22:52 修改
阅读量890 收藏 4
点赞数 3
分类专栏： Java 文章标签： java
于 2022-03-07 13:41:28 首次发布
原文链接：https://github.com/cosen1024/Java-Interview
版权

内容来源 https://github.com/cosen1024/Java-Interview

线程池核心设计与实现

2.1 总体设计

Java中的线程池核心实现类是ThreadPoolExecutor

图1 ThreadPoolExecutor UML类图

ThreadPoolExecutor实现的顶层接口是Executor，顶层接口Executor提供了一种思想：将任务提交和任务执行进行解耦。用户无需关注如何创建线程，如何调度线程来执行任务，用户只需提供Runnable对象，将任务的运行逻辑提交到执行器(Executor)中，由Executor框架完成线程的调配和任务的执行部分。

ThreadPoolExecutor将会一方面维护自身的生命周期，另一方面同时管理线程和任务，使两者良好的结合从而执行并行任务。

ThreadPoolExecutor是如何运行，如何同时维护线程和执行任务的呢？其运行机制如下图所示：

图2 ThreadPoolExecutor运行流程

线程池在内部实际上构建了一个生产者消费者模型，将线程和任务两者解耦，并不直接关联，从而良好的缓冲任务，复用线程。

线程池的运行主要分成两部分：任务管理、线程管理。任务管理部分充当生产者的角色，当任务提交后，线程池会判断该任务后续的流转：（1）直接申请线程执行该任务；（2）缓冲到队列中等待线程执行；（3）拒绝该任务。

线程管理部分是消费者，它们被统一维护在线程池内，根据任务请求进行线程的分配，当线程执行完任务后则会继续获取新的任务去执行，最终当线程获取不到任务的时候，线程就会被回收。

线程池运行机制：

  1. 线程池如何维护自身状态。
  2. 线程池如何管理任务。
  3. 线程池如何管理线程。

2.2 生命周期管理

线程池运行的状态，并不是用户显式设置的，而是伴随着线程池的运行，由内部来维护。线程池内部使用一个变量维护两个值：运行状态(runState)和线程数量 (workerCount)。

如下代码所示：

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

ctl这个AtomicInteger类型，是对线程池的运行状态和线程池中有效线程的数量进行控制的一个字段， 它同时包含两部分的信息：线程池的运行状态 (runState) 和线程池内有效线程的数量 (workerCount)，高3位保存runState，低29位保存workerCount，两个变量之间互不干扰。用一个变量去存储两个值，可避免在做相关决策时，出现不一致的情况，不必为了维护两者的一致，而占用锁资源。

ThreadPoolExecutor的运行状态有5种，分别为：

img

其生命周期转换如下入所示：

图3 线程池生命周期

图3 线程池生命周期

参数

keepAliveTime：非核心线程空闲时间（没有任务执行时）达到keepAliveTime，该线程会退出（避免资源浪费就应该要退出）

2.3 任务执行机制

任务调度是线程池的主要入口，当用户提交了一个任务，接下来这个任务将如何执行都是由这个阶段决定的。了解这部分就相当于了解了线程池的核心运行机制。

首先，所有任务的调度都是由execute方法完成的，这部分完成的工作是：检查现在线程池的运行状态、运行线程数、运行策略，决定接下来执行的流程，是直接申请线程执行，或是缓冲到队列中执行，亦或是直接拒绝该任务。其执行过程如下：

  1. 首先检测线程池运行状态，如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。
  2. 如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务。
  3. 如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。
  4. 如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。
  5. 如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

其执行流程如下图所示：

图4 任务调度流程

图4 任务调度流程

2.3.2 任务缓冲

任务缓冲模块是线程池能够管理任务的核心部分。线程池的本质是对任务和线程的管理，而做到这一点最关键的思想就是将任务和线程两者解耦，不让两者直接关联，才可以做后续的分配工作。线程池中是以生产者消费者模式，通过一个阻塞队列来实现的。阻塞队列缓存任务，工作线程从阻塞队列中获取任务。

阻塞队列(BlockingQueue)是一个支持两个附加操作的队列。这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的线程会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

下图中展示了线程1往阻塞队列中添加元素，而线程2从阻塞队列中移除元素：

图5 阻塞队列

图5 阻塞队列

使用不同的队列可以实现不一样的任务存取策略。在这里，我们可以再介绍下阻塞队列的成员：

img

2.4 Worker线程管理

2.4.1 Worker线程

线程池为了掌握线程的状态并维护线程的生命周期，设计了线程池内的工作线程Worker。我们来看一下它的部分代码：

private final class Worker extends AbstractQueuedSynchronizer implements Runnable{
    final Thread thread;//Worker持有的线程
    Runnable firstTask;//初始化的任务，可以为null
}

Worker这个工作线程，实现了Runnable接口，并持有一个线程thread，一个初始化的任务firstTask。thread是在调用构造方法时通过ThreadFactory来创建的线程，可以用来执行任务；firstTask用它来保存传入的第一个任务，这个任务可以有也可以为null。如果这个值是非空的，那么线程就会在启动初期立即执行这个任务，也就对应核心线程创建时的情况；如果这个值是null，那么就需要创建一个线程去执行任务列表（workQueue）中的任务，也就是非核心线程的创建。

Worker执行任务的模型如下图所示：

图7 Worker执行任务

图7 Worker执行任务

线程池需要管理线程的生命周期，需要在线程长时间不运行的时候进行回收。线程池使用一张Hash表去持有线程的引用，这样可以通过添加引用、移除引用这样的操作来控制线程的生命周期。这个时候重要的就是如何判断线程是否在运行。

Worker是通过继承AQS，使用AQS来实现独占锁这个功能。没有使用可重入锁ReentrantLock，而是使用AQS，为的就是实现不可重入的特性去反应线程现在的执行状态。

1.lock方法一旦获取了独占锁，表示当前线程正在执行任务中。 2.如果正在执行任务，则不应该中断线程。 3.如果该线程现在不是独占锁的状态，也就是空闲的状态，说明它没有在处理任务，这时可以对该线程进行中断。 4.线程池在执行shutdown方法或tryTerminate方法时会调用interruptIdleWorkers方法来中断空闲的线程，interruptIdleWorkers方法会使用tryLock方法来判断线程池中的线程是否是空闲状态；如果线程是空闲状态则可以安全回收。

在线程回收过程中就使用到了这种特性，回收过程如下图所示：

图8 线程池回收过程

2.4.2 Worker线程增加

增加线程是通过线程池中的addWorker方法，该方法的功能就是增加一个线程，该方法不考虑线程池是在哪个阶段增加的该线程，这个分配线程的策略是在上个步骤完成的，该步骤仅仅完成增加线程，并使它运行，最后返回是否成功这个结果。addWorker方法有两个参数：firstTask、core。firstTask参数用于指定新增的线程执行的第一个任务，该参数可以为空；core参数为true表示在新增线程时会判断当前活动线程数是否少于corePoolSize，false表示新增线程前需要判断当前活动线程数是否少于maximumPoolSize，其执行流程如下图所示：

图9 申请线程执行流程图

图9 申请线程执行流程图

2.4.3 Worker线程回收

线程池中线程的销毁依赖JVM自动的回收，线程池做的工作是根据当前线程池的状态维护一定数量的线程引用，防止这部分线程被JVM回收，当线程池决定哪些线程需要回收时，只需要将其引用消除即可。Worker被创建出来后，就会不断地进行轮询，然后获取任务去执行，核心线程可以无限等待获取任务，非核心线程要限时获取任务。当Worker无法获取到任务，也就是获取的任务为空时，循环会结束，Worker会主动消除自身在线程池内的引用。

try {
  while (task != null || (task = getTask()) != null) {
    //执行任务
  }
} finally {
  processWorkerExit(w, completedAbruptly);//获取不到任务时，主动回收自己
}

线程回收的工作是在processWorkerExit方法完成的。

图10 线程销毁流程

图10 线程销毁流程

事实上，在这个方法中，将线程引用移出线程池就已经结束了线程销毁的部分。但由于引起线程销毁的可能性有很多，线程池还要判断是什么引发了这次销毁，是否要改变线程池的现阶段状态，是否要根据新状态，重新分配线程。

2.4.4 Worker线程执行任务

在Worker类中的run方法调用了runWorker方法来执行任务，runWorker方法的执行过程如下：

1.while循环不断地通过getTask()方法获取任务。 2.getTask()方法从阻塞队列中取任务。 3.如果线程池正在停止，那么要保证当前线程是中断状态，否则要保证当前线程不是中断状态。 4.执行任务。 5.如果getTask结果为null则跳出循环，执行processWorkerExit()方法，销毁线程。

执行流程如下图所示：

图11 执行任务流程

图11 执行任务流程

线程池参数设置

1. 常规设置

分 IO 密集型任务或者分 CPU 密集型任务

CPU 密集型任务

CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading 很高。

CPU密集型：corePoolSize = CPU核数 + 1

《Java并发编程实战》一书中给出的原因是：**即使当计算（CPU）密集型的线程偶尔由于页缺失故障或者其他原因而暂停时，这个“额外”的线程也能确保 CPU 的时钟周期不会被浪费。**把它理解为一个备份的线程就行了。

注意：这个地方还有个需要注意的小点就是，如果你的服务器上部署的不止一个应用，你就得考虑其他的应用的线程池配置情况。

经过精密的计算，你咔一下设置为核心数，结果项目部署上去了，发现还有其他的应用在和你抢 CPU。

IO 密集型任务

IO密集型的话，是指系统大部分时间在跟I/O交互，而这个时间线程不会占用CPU来处理，即在这个时间范围内，可以由其他线程来使用CPU，因而可以多配置一些线程。

业界的一些线程池参数配置方案：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9eGU5iY2-1646631675435)(https://user-gold-cdn.xitu.io/2020/4/13/17171bd786f4b4a7?w=1316&h=782&f=png&s=180624)]

第一个就是我们上面说的，和实际业务场景有所偏离。

第二个设置为 2*CPU 核心数，有点像是把任务都当做 IO 密集型去处理了。而且一个项目里面一般来说不止一个自定义线程池吧？比如有专门处理数据上送的线程池，有专门处理查询请求的线程池，这样去做一个简单的线程隔离。但是如果都用这样的参数配置的话，显然是不合理的。

第三个不说了，理想状态。流量是不可能这么均衡的，就拿美团来说，下午3，4点的流量，能和 12 点左右午饭时的流量比吗？

2. 线程池参数动态化

可以将修改线程池参数的成本降下来，这样至少可以发生故障的时候可以快速调整从而缩短故障恢复的时间。可以将线程池的参数从代码中迁移到分布式配置中心上，实现线程池参数可动态配置和即时生效，线程池参数动态化前后的参数修改流程对比如下：

图16 动态修改线程池参数新旧流程对比

成本在于实现动态化以及监控成本不高，收益在于：在不颠覆原有线程池使用方式的基础之上，从降低线程池参数修改的成本以及多维度监控这两个方面降低了故障发生的概率。希望本文提供的动态化线程池思路能对大家有帮助。

3.2.1 整体设计

动态化线程池的核心设计包括以下三个方面：

  1. 简化线程池配置：线程池构造参数有8个，但是最核心的是3个：corePoolSize、maximumPoolSize，workQueue，它们最大程度地决定了线程池的任务分配和线程分配策略。考虑到在实际应用中我们获取并发性的场景主要是两种：（1）并行执行子任务，提高响应速度。这种情况下，应该使用同步队列，没有什么任务应该被缓存下来，而是应该立即执行。（2）并行执行大批次任务，提升吞吐量。这种情况下，应该使用有界队列，使用队列去缓冲大批量的任务，队列容量必须声明，防止任务无限制堆积。所以线程池只需要提供这三个关键参数的配置，并且提供两种队列的选择，就可以满足绝大多数的业务需求，Less is More。
  2. 参数可动态修改：为了解决参数不好配，修改参数成本高等问题。在Java线程池留有高扩展性的基础上，封装线程池，允许线程池监听同步外部的消息，根据消息进行修改配置。将线程池的配置放置在平台侧，允许开发同学简单的查看、修改线程池配置。
  3. 增加线程池监控：对某事物缺乏状态的观测，就对其改进无从下手。在线程池执行任务的生命周期添加监控能力，帮助开发同学了解线程池状态。

图17 动态化线程池整体设计

图17 动态化线程池整体设计

3.3.2 功能架构

动态化线程池提供如下功能：

动态调参：支持线程池参数动态调整、界面化操作；包括修改线程池核心大小、最大核心大小、队列长度等；参数修改后及时生效。 任务监控：支持应用粒度、线程池粒度、任务粒度的Transaction监控；可以看到线程池的任务执行情况、最大任务执行时间、平均任务执行时间、95/99线等。 负载告警：线程池队列任务积压到一定值的时候会通过大象（美团内部通讯工具）告知应用开发负责人；当线程池负载数达到一定阈值的时候会通过大象告知应用开发负责人。 操作监控：创建/修改和删除线程池都会通知到应用的开发负责人。 操作日志：可以查看线程池参数的修改记录，谁在什么时候修改了线程池参数、修改前的参数值是什么。 权限校验：只有应用开发负责人才能够修改应用的线程池参数。

图18 动态化线程池功能架构
3.2.2 参数动态化

JDK允许线程池使用方通过ThreadPoolExecutor的实例来动态设置线程池的核心策略，以setCorePoolSize为方法例，在运行期线程池使用方调用此方法设置corePoolSize之后，线程池会直接覆盖原来的corePoolSize值，并且基于当前值和原始值的比较结果采取不同的处理策略。对于当前值小于当前工作线程数的情况，说明有多余的worker线程，此时会向当前idle的worker线程发起中断请求以实现回收，多余的worker在下次idel的时候也会被回收；对于当前值大于原始值且当前队列中有待执行任务，则线程池会创建新的worker线程来执行队列任务，setCorePoolSize具体流程如下：

图20 setCorePoolSize方法执行流程

setMaximumPoolSize 也可以设置：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-q1TzTopT-1646631675436)(https://user-gold-cdn.xitu.io/2020/4/13/17171bf556d917b4?w=678&h=484&f=png&s=58571)]

这个地方就很简单了，逻辑不太复杂。

1.首先是参数合法性校验。

2.然后用传递进来的值，覆盖原来的值。

3.判断工作线程是否是大于最大线程数，如果大于，则对空闲线程发起中断请求。

经过前面两个方法的分析，我们知道了最大线程数和核心线程数可以动态调整。

重点是基于这几个public方法，我们只需要维护ThreadPoolExecutor的实例，并且在需要修改的时候拿到实例修改其参数即可。基于以上的思路，我们实现了线程池参数的动态化、线程池参数在管理平台可配置可修改，

如何动态指定队列长度？

按照这个思路自定义一个队列，让其可以对 Capacity 参数进行修改即可。

操作起来也非常方便，把 LinkedBlockingQueue 粘贴一份出来，修改个名字，然后把 Capacity 参数的 final 修饰符去掉，并提供其对应的 get/set 方法。

面试题

  1. 问题一：线程池被创建后里面有线程吗？如果没有的话，你知道有什么方法对线程池进行预热吗？

    线程池被创建后如果没有任务过来，里面是不会有线程的。如果需要预热的话可以调用下面的两个方法：

    全部启动：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TjNcl79K-1646631675436)(https://user-gold-cdn.xitu.io/2020/4/13/17171c171c60521f?w=629&h=309&f=png&s=25599)]

    仅启动一个：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vF2MzLvO-1646631675436)(https://user-gold-cdn.xitu.io/2020/4/13/17171c17c927454d?w=600&h=285&f=png&s=31464)]

  2. 问题二：核心线程数会被回收吗？需要什么设置？

    核心线程数默认是不会被回收的，如果需要回收核心线程数，需要调用下面的方法：

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hKPCz00X-1646631675436)(https://user-gold-cdn.xitu.io/2020/4/13/17171c19ad0f4a22?w=881&h=615&f=png&s=75243)]

    allowCoreThreadTimeOut 该值默认为 false。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lR6q8jQv-1646631675437)(https://user-gold-cdn.xitu.io/2020/4/13/17171c1a876f3451?w=581&h=150&f=png&s=13301)]

参考

https://tech.meituan.com/2020/04/02/java-pooling-pratice-in-meituan.html

https://blog.csdn.net/z55887/article/details/79060070

https://www.cnblogs.com/thisiswhy/p/12690630.html

http://ifeve.com/how-to-calculate-threadpool-size/

OOooo--
关注
专栏目录
掰开揉碎了教你设计线程池，还不来学？
hailong66666的博客
12-03 447
线程池设计思路 线程池是什么 我们先来打个比方，线程池就好像一个工具箱，我们每次需要拧螺丝的时候都要从工具箱里面取出一个螺丝刀来，有时候需要取出一个来拧，有时候螺丝多的时候需要多个人取出多个来拧，拧完自己的螺丝那么就会把螺丝刀再放回去，然后别人下次用的时候再取出来用。也许我的例子不是太完美，但是我想我已经基本阐述清楚了线程池。说白了线程池就是相当于提前申请了一些资源也就是线程，需要的时候就从线程池中取出线程来处理一些事情，处理完毕之后再把线程放回去。 为什么需要线程池 我们来思考一个问题，为什么需要线程池
你还不懂线程池的设计及原理吗？掰开揉碎了教你设计线程池
Linuxhus的博客
06-11 259
大家在学习线程池的时候也曾查阅过各种资料，但是感觉大佬写的很好但是写的不够详细，写的详细的设计思路又很简单，所以我的出发点就是让读者可以清晰明确的看懂整个设计思想和设计过程，可以举一反三，在今后内存池等方面也可以游刃有余的设计出来！好了，正文开始~我们先来打个比方，线程池就好像一个工具箱，我们每次需要拧螺丝的时候都要从工具箱里面取出一个螺丝刀来，有时候需要取出一个来拧，有时候螺丝多的时候需要多个人取出多个来拧，拧完自己的螺丝那么就会把螺丝刀再放回去，然后别人下次用的时候再取出来用。也许我的例子不是太完美，但
一个线程池的设计
05-19
一个线程池的设计
如何设计一个线程池
热爱编程的机械生的救赎
09-20 1009
其实设计线程池本质上就是问你现有的线程池的原理，只是让你换个思路回答设计一个线程池应该从以下几个方面入手：线程池有哪些状态，如何维护这个状态重要的成员变量有哪些？任务执行机制是什么？拒绝策略有哪些？线程怎么封装？用什么来存储线程？
C++ 线程池设计
最新发布
qq_50373827的博客
10-08 974
执行任务 (Task::execute) |-------------------------------------->+---------------------+| 添加任务到TaskManager|---------------------------------------->+-----------------------+// 模拟I/O操作。+-------------------------+ 任务执行后，调用回调函数。// 通知所有等待中的线程，防止它们一直阻塞。
线程池设计
潜心钻研技术
05-15 799
这些必须都传给线程池中的线程才行，线程池中的线程从任务中拿取输入数据调用解决方法，最后把输出结果写入，线程池不需要对任务做任何多余的操作！而这个方法函数叫做——回调函数。大体思路是：任务队列不为空就通过条件变量向线程池中的线程发送信号执行任务，如果任务队列为空，则线程池中的线程在cond条件变量下等待。大体思路是： 把信号量的大小设置成任务队列task_queue的大小，这样临界资源的粒度就变小了，实现了生产和消费的解耦。最后线程池被设计成了单例模式，可以保证该线程池全局唯一。结构体中的对象包括👇。
线程池的设计
wjfdsklfdkfksd的博客
04-27 763
线程池就是创建若干个可执行的线程放到容器中，有任务处理时，会提交到线程池中的任务队列中，线程处理完不是销毁，而是阻塞等待下一个任务。
多线程之线程池设计
qq492927689的博客
05-16 613
代码下载地址： https://gitee.com/dai-jiapei/iocp/tree/master/Thread 主要下载 demo.c ,threadpool.c, threadpool.h 三个文件即可 这个一个跨系统线程池，支持Linux, windows。其中包含XP，需要将threadpool.c::COMPATIBLE_XP 这个宏定义为 1。XP 需要宏控制是因为XP没有条件变量，只能自己实现一个，当 COMPATIBLE_XP 为0时， 使用系统提供的条件变量函数。 线程池这东西，
基于Java线程池技术的数据爬虫设计与实现.pdf
07-02
在实际开发中，需要注意线程安全问题，合理设计线程池的大小，以及合理配置线程池中线程的参数，以达到最优的性能表现。通过这些方法，数据爬虫可以在保证高效爬取数据的同时，还能保持良好的系统资源利用率。
如何根据系统的业务场景需求定制自己的线程池？
佐杰的博客
05-27 1021
自定义线程工厂，需要实现ThreadFactory接口，此处提供一个参考实现，如图5所示，大家可以根据这个代码样例进行扩展，实现自己的线程工厂，当然也建议大家多去阅读优秀的开源框架，比如Netty、Tomcat，它们都提供了优秀的自定义的线程工厂的实现。我们以I/O密集型任务为例，实现一个自定义线程池的案例，具体代码如图我们定义了一个订单同步线程池，指定核心线程数为CPU数量+1，最大线程数为CPU数量*2，并指定非核心线程数的存活时间为60s。
如何构造一个线程池 ?
xx12321q的博客
06-05 954
前言 在没接触线程池之前, 我们都是在哪用到线程就在哪创建, 这样做看似方便, 但如果在高并发的前提下, 频繁的创建消耗可是一笔不小的开销, 严重则会影响到性能, 所以在此我们提出了线程池的概念 , 让线程执行完任务后并不立即销毁, 而是等待其他任务 线程池概述 jdk5 之前, 想使用线程池必须自己去实现, jdk5 之后, java内置了线程池实现Executors (SingleThreadExecutor等)来创建不同类型的线程池 , 但实际开发中我们一般不使用它......
线程池设计, 从简单的我们平常设计线程池图解,到生活中的类似线程池的处理现实场景, 到简单的C++模拟nginx写的单链表组织工作队列的简单线程池实现 + nginx 部分源码刨析
小杰312的博客
01-29 5564
线程池设计, 从简单的我们平常设计线程池图解,到生活中的类似线程池的处理现实场景, 到简单的C语言C++模拟nginx写的单链表组织工作队列的简单线程池实现 + nginx 部分源码刨析到最后分析池化技术的好处..... 一篇文章基本入门线程池
线程池的设计与实现
wbcp2000的专栏
12-31 2945
2006转眼就要过去了，今天是2006年最后一天，特此总结一下关于线程池的设计与实现，与各位大虾共享，也算是给所有认识的、不认识的朋友，一个小小礼物。嘎嘎。         言归正传，我们先来说说线程池的相关概念。一、什么是池。池的英文名：POOL，可以理解个容器，一个水缸。打个比方，我小时住在农村，家里都有个水缸，父母会每天早上从湖里，跳水倒满水缸，这样一天的生活用水就准备好了。当我
线程池设计详解
wh柒八九的博客
03-19 503
随着计算机行业的飞速发展，摩尔定律逐渐失效，多核CPU成为主流。使用多线程并行计算逐渐成为开发人员提升服务器性能的基本武器。J.U.C提供的线程池：ThreadPoolExecutor类，帮助开发人员管理线程并方便地执行并行任务。了解并合理使用线程池，是一个开发人员必修的基本功。 文章目录线程池是什么 线程池是什么 线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。 线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降.
Java 线程池技术之一 自实现线程池
热门推荐
IterZebra
09-15 1万+
尽管自jdk1.5，Java已经自带了线程池实现，了解如何自己实现Java线程池有助于加深对操作系统和Java虚拟机的理解。 一，线程池的基本要素 线程池一般需要一个线程管理类： ThreadPoolManager，其作用有：   1）提供创建一定数量的线程
线程池，我的设计参考
07-12 1579
http://blog.csdn.net/zy825316/article/details/19305473
【线程池】--- 线程池的设计
Beat_Boxer的博客
08-30 278
CPU密集型（CPU-bound） CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading很高。 在多重程序系统中，大部份时间用来做计算、逻辑判断等CPU动作的程序称之CPU bound。例如一个...
c++设计线程池类启用单个线程的流程以及示例
06-02
启用单个线程的线程池类示例代码如下： ```cpp #include <iostream> #include <thread> #include <queue> #include <functional> #include <mutex> #include <condition_variable> class ThreadPool { public: ThreadPool() : stopped(false) {} ~ThreadPool() { stop(); } void enqueue(std::function<void()> task) { { std::unique_lock<std::mutex> lock{mutex}; tasks.push(task); } condition.notify_one(); } void start() { for (int i = 0; i < 1; ++i) { workers.emplace_back([this] { while (true) { std::unique_lock<std::mutex> lock{mutex}; while (!stopped && tasks.empty()) { condition.wait(lock); } if (stopped && tasks.empty()) { return; } auto task = tasks.front(); tasks.pop(); lock.unlock(); task(); } }); } } void stop() { { std::unique_lock<std::mutex> lock{mutex}; stopped = true; } condition.notify_all(); for (auto& worker : workers) { worker.join(); } } private: std::queue<std::function<void()>> tasks; std::vector<std::thread> workers; std::mutex mutex; std::condition_variable condition; bool stopped; }; int main() { ThreadPool pool; pool.start(); pool.enqueue([] { std::cout << "Hello from task 1!" << std::endl; }); pool.enqueue([] { std::cout << "Hello from task 2!" << std::endl; }); pool.stop(); return 0; } ``` 在这个示例代码中，我们创建了一个 ThreadPool 类，其中包含一个队列用于存储待执行的任务，一个线程池用于执行任务，以及一个互斥锁和条件变量用于同步任务的执行。我们还提供了 enqueue() 方法，用于将任务添加到队列中。在 start() 方法中，我们启动一个单独的线程，该线程不断地从队列中获取任务并执行它们。在 stop() 方法中，我们设置了 stopped 标志，通知所有线程停止执行任务。在主函数中，我们创建了一个 ThreadPool 实例，添加了两个任务，并在程序退出时停止线程池。 需要注意的是，这个示例代码中只启用了一个线程来执行任务。如果需要启用多个线程，只需将 for 循环中的 1 改为需要的线程数即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值