【Java笔记】多线程1：线程池大小为什么设置N+1或2N？CPU密集型？IO密集型？

已于 2024-04-19 23:19:55 修改
阅读量738 收藏 20
点赞数 13
分类专栏： Java 文章标签： java 笔记 面试
于 2024-04-07 15:07:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hansdas/article/details/137461063
版权

经典面试题：线程池设置多大合适

文章目录


大家都知道这个问题需要根据不同场景来回答：

  • CPU密集型运算：N+1
  • IO密集型运算：2N

那么，就有几个问题：

  1. N是什么？
  2. 什么是IO密集型运算？什么又是CPU密集型运算？
  3. 为什么是2N？又为什么是N+1？

下面就稍微梳理下

1. N

1.1 什么是N

需要注意的是，N是最大并行数，而不是“X核CPU”的X。
一般我们会听到例如“4核8线程”的说法，这里的8就是N，虽然只有4个CPU（核心），但是可以利用超线程技术把原来CPU4个线程虚拟成8个。

1.2 如何查看N

Runtime.getRuntime().availableProcessors();

会返回计算机的最大并行数

2. IO密集型运算与CPU密集型运算

  • IO密集型运算：就是指需要频繁输入输出的场景，这里的IO不仅包括操作数据库时的磁盘-内存IO，也包括网络远程调用的IO。
  • CPU密集型运算：CPU运算需求高的场景，比如循环次数很多，或者递归调用层次很深等

3. 为什么是2N？又为什么是N+1？

首先要明确，2N跟N+1都是经验值，大家能明白大概的逻辑就行

3.1 为什么IO密集型运算最大线程数是2N?

这个有一个公式：

理想线程数=最大并行数*期望CPU利用率*(CPU计算时间+等待时间)/CPU计算时间

下面我们试图理解一下。首先先明公式里几个变量的意义：

  • 最大并行数：就是前面说的N
  • 期望CPU利用率：最理想的情况肯定是希望利用率100%（发热严重？那不管我事）
  • CPU计算时间：就是字面意思
  • 等待时间：等待数据IO的时间

首先要明确，在涉及大量数据IO的场景下，CPU利用率最高的时候是什么时候？肯定是当任务A在等待IO时，CPU可以切到任务B进行CPU运算，保证CPU不会因为等待IO而停下来。

因此会有 最大并行数*(CPU计算时间+等待时间)/CPU计算时间
如果理想地认为CPU计算时间等于等待时间，那么就是2N了。

当然大部分场景下这是不可能的，一般Web项目中IO时间，也就是上面说的CPU等待时间，都远高于CPU处理时间（因此MySQL才会用B+树做索引来减小每查找一层增加的IO）。比如一个简单的数据库查询，计算可能只有0.1ms，IO则可能达到2ms，这样一算，得21N了。所以2N只是个理想的经验值，在高IO时间开销的场景，可以是10N、20N、30N等等。

3.2 为什么CPU密集型运算的最大线程数是N+1

回到我们的出发点：希望CPU一刻不停的工作。
CPU密集型运算场景下，我们就不再考虑IO了。这时候CPU空闲的原因一般就是正在处理的任务出现错误，暂停了。这个时候如果我们有另一个任务恰好补上来，那CPU就没得歇了。所以是N+1。当然这也是经验值。

网上也有说法是，CPU密集型运算的最大线程数可以设置在N~2N，这个也不难理解，如果我们N个实际线程都在处理任务，他们发生了错误，每个都有个替补的补上，这就是2N了。

但1.5N或者2N之类比较大的线程数也不一定是最好的，前面的一切分析都是基于“提高CPU利用率”这个目的，但是不一定代表速度就快，对于任务失败可能性比较低的场景，设2N属于纯粹没事找事，因为并不需要这么多候补的任务，多出来的一起排队反而是给缓存上强度，上下文切换的时候开销更大了（大概）。之前由朋友做课程实验，是起多个线程并行做矩阵运算，发现其实N是最快的，因为矩阵运算失败可能性很小。

Reference

https://blog.csdn.net/Cover_sky/article/details/121371973
https://cloud.tencent.com/developer/article/1730603

Hansdas
关注
  • 13
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java多线程学习笔记之自定义线程池
08-29
本篇文章主要介绍了java多线程学习笔记之自定义线程池 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java多线程+网银取款案例精讲
06-10
课程简介本课程是《Java初级至应用》系统课程的第十章，全套课程精细讲解，课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java工程师或系统架构师岗位，课程提供全套代码笔记其它相关...
线程池线程数设置多少为合适？
最新发布
weixin_43005845的博客
01-02 911
5、可根据公式先设置一个数值，然后再根据实际的业务场景来调整。N是CPU的总和数。CPU密集型：线程池大小设置为N+1。IO密集型：线程池大小设置为2N+1。4、一次业务的整体耗时。2、服务器的配置情况。
线程池详解
weixin_43960071的博客
07-28 676
1 线程池作用 降低资源消耗。通过重复利用已创建的线程，来降低线程创建、销毁线程造成资源的消耗。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配、调优和监控。 2 线程池的状态 RUNNING 可以接收新的任务，正常工作。可以通过shutdown() 转为 SHUTDOWN SHUTDOWN 不会接收新任务，但会执行已接收的队列中的任务。该状态下 如果队列中任务都执行完，数量为0 ，工作线程也为0则会转为 TDIYING 状
为什么说IO密集型业务，线程数是CPU数的2倍？
BASK2312的博客
01-04 186
如果I/O请求的速度比较快，和CPU的耗时对等的时候，我们把处理I/O的线程数，设置成 CPU 的 2倍，是合理的。但现实中并没有这么多如果，我们要处理秒成千上万的I/O请求，注定了它的耗时要比CPU多的多。对于一个Tomcat来说，它处理的大多数都是I/O密集型的业务，可以说是最好的实践场景。大部分I/O请求，在发起之后，就进入等待状态，这个等待状态不会浪费CPU，所以一台机器在同一时刻支持的I/O请求，可以很多。I/O请求不仅仅指的是磁盘读写，在互联网服务中更多指的是网络I/O请求。
线程池各个参数设置说明
qq_25705173的博客
09-19 568
任务队列长度一般设计为:核心线程数单个任务执行时间*2即可;核心线程数设计为10.单个任务执行时间为0.1秒,则队列长度可以设计为200;一般用的是linkedBlockQueue,队列进出比较方便。参照核心线程数设置说明。
IO密集型和CPU密集型
酷小亚
06-13 4698
需非常多CPU计算资源，让每个CPU核心都参与计算，CPU性能充分利用，避免过多线程上下文切换，理想方案是：线程数 = CPU核数+1也可CPU核数*2，要看JDK版本，及CPU配置(服务器CPU有超线程)。1.8来增加并行计算，想线程数 = CPU内核线程数*2网络、磁盘 IO （与DB、缓存），一旦IO，线程就等待，结束才执行。多设线程数，等待时去做其它事，提高效率。线程上下文切换有代价。IO密集型公式：线程数 = CPU核心数/(1-阻塞系数) 阻塞系数一般0.8~0.9，双核CPU理想线程数
Java异常处理+集合+IO流+多线程+网络编程
06-10
本课程是《Java初级至应用》系统课程的第三模块，全套课程精细讲解，课程超过其他机构30%的课程量，经过我们全套课程系统学习的同学，可轻松从事Java工程师或系统架构师岗位，课程提供全套代码笔记其它相关素材及...
java-demo:java学习笔记，包含多线程，java IO流，java 阻塞IO，非阻塞IO，netty demo
05-26
java 技术基础java IO知识BIO
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
学习目录：1. 线程简介 2. 线程实现（重点） 3. 线程状态 4. 线程同步（重点） 5. 线程通信问题 6. 高级主题
深入理解CPU密集型与IO密集型任务、线程池如何选择？
weixin_44440311的博客
08-22 1099
深入理解CPU密集型与IO密集型任务、线程池如何选择？
Callable接口使用demo
a2231476020的博客
08-27 203
public class MyCallableTask implements Callable<String> { int i; public MyCallableTask(int i) { this.i = i; } @Override public String call() throws Exception { Thread.sleep(1000); return Thread.currentThr
面试官：线程池大小设置多少，比较合适？
犬小哈
11-14 80
来源：https://dip-mazumder.medium.com???? 欢迎加入小哈的星球，你将获得:专属的项目实战/ Java 学习路线 / 一对一提问 / 学习打卡/ 赠书福利目前, 正在星球内部带小伙伴做第一个项目：全栈前后端分离博客，手摸手，后端 + 前端全栈开发，从 0 到 1 讲解每个功能点开发步骤，1v1 答疑，直到项目上线。目前已更新了141小节，累计22w+字，讲解图：91...
CPU密集型与IO密集型任务_线程池配置
tot_lbr的博客
12-07 282
在使用线程池时，我们需要根据任务类型的不同进行优化配置。这里介绍一下CPU密集型和IO密集型任务的特点，并研究在这两种场景下使用线程池时应该注意的事项。
合理的估算线程池的大小
向日葵
08-02 1769
一般说来，大家认为线程池的大小经验值应该这样设置：（其中N为CPU的个数） 如果是CPU密集型应用，则线程池大小设置为N+1如果是IO密集型应用，则线程池大小设置为2N+1 如果一台服务器上只部署这一个应用并且只有这一个线程池，那么这种估算或许合理，具体还需自行测试验证。 但是，IO优化中，这样的估算公式可能更适合： 最佳线程数目 = （（线程等待时间+线程CPU时间）/线程CPU时间
配置线程数量
weixin_45650737的博客
11-18 185
配置线程数量之前，首先要看任务的类型是 IO密集型，还是CPU密集型？ 什么是IO密集型？ 比如：频繁读取磁盘上的数据，或者需要通过网络远程调用接口。 什么是CPU密集型？ 比如：非常复杂的调用，循环次数很多，或者递归调用层次很深等。 IO密集型配置线程数经验值是：2N，其中N代表CPU核数。 CPU密集型配置线程数经验值是：N + 1，其中N代表CPU核数。 如果获取N的值？ int availableProcessors = Runtime.getRuntime().availableProcessor
Executor线程池的最佳线程数量计算
热门推荐
wangpeng322的博客
06-19 1万+
如果是IO密集型应用，则线程池大小设置为2N+1； 如果是CPU密集型应用，则线程池大小设置为N+1； N代表CPU的核数。 假设我的服务器是4核的，且一般进行大数据运算，cpu消耗较大，那么线程池数量设置为5为最优。 （现在很多项目线程池滥用，注意分配线程数量，建议不要动态创建线程池，尽量将线程池配置在配置文件中，这样方便以后整体的把控和后期维护。每个核心业务线程池要互相独立，互不影响。...
Java多线程编程学习笔记之十二：生产者—消费者模型（含代码）
06-02
好的，下面是Java多线程编程学习笔记之十二：生产者—消费者模型的相关内容和代码。 ## 生产者—消费者模型简介 生产者—消费者模型是一种常见的多线程并发模型，它涉及到两个角色：生产者和消费者。生产者负责生产数据，消费者负责消费数据。生产者和消费者通过一个共享的缓冲区进行通信，生产者将数据放入缓冲区，消费者从缓冲区获取数据。 在多线程编程中，生产者—消费者模型的实现有多种方式，本文将介绍一种基于Java的实现方式。 ## 生产者—消费者模型的实现 ### 1. 定义共享缓冲区 共享缓冲区是生产者和消费者进行通信的桥梁，它需要实现以下功能： - 提供一个put方法，允许生产者将数据放入缓冲区； - 提供一个take方法，允许消费者从缓冲区获取数据； - 当缓冲区已满时，put方法应该等待； - 当缓冲区为空时，take方法应该等待。 以下是一个简单的共享缓冲区的实现： ```java public class Buffer { private int[] data; private int size; private int count; private int putIndex; private int takeIndex; public Buffer(int size) { this.data = new int[size]; this.size = size; this.count = 0; this.putIndex = 0; this.takeIndex = 0; } public synchronized void put(int value) throws InterruptedException { while (count == size) { wait(); } data[putIndex] = value; putIndex = (putIndex + 1) % size; count++; notifyAll(); } public synchronized int take() throws InterruptedException { while (count == 0) { wait(); } int value = data[takeIndex]; takeIndex = (takeIndex + 1) % size; count--; notifyAll(); return value; } } ``` 上面的Buffer类使用一个数组来表示缓冲区，size表示缓冲区的大小，count表示当前缓冲区中的元素数量，putIndex和takeIndex分别表示下一个可写和可读的位置。put和take方法都是同步方法，使用wait和notifyAll来进行线程间的等待和通知。 ### 2. 定义生产者和消费者 生产者和消费者都需要访问共享缓冲区，因此它们都需要接收一个Buffer对象作为参数。以下是生产者和消费者的简单实现： ```java public class Producer implements Runnable { private Buffer buffer; public Producer(Buffer buffer) { this.buffer = buffer; } public void run() { try { for (int i = 0; i < 10; i++) { buffer.put(i); System.out.println("Produced: " + i); Thread.sleep((int)(Math.random() * 1000)); } } catch (InterruptedException e) { e.printStackTrace(); } } } public class Consumer implements Runnable { private Buffer buffer; public Consumer(Buffer buffer) { this.buffer = buffer; } public void run() { try { for (int i = 0; i < 10; i++) { int value = buffer.take(); System.out.println("Consumed: " + value); Thread.sleep((int)(Math.random() * 1000)); } } catch (InterruptedException e) { e.printStackTrace(); } } } ``` 生产者在一个循环中不断地向缓冲区中放入数据，消费者也在一个循环中不断地从缓冲区中获取数据。注意，当缓冲区已满时，生产者会进入等待状态；当缓冲区为空时，消费者会进入等待状态。 ### 3. 测试 最后，我们可以使用下面的代码来进行测试： ```java public class Main { public static void main(String[] args) { Buffer buffer = new Buffer(5); Producer producer = new Producer(buffer); Consumer consumer = new Consumer(buffer); Thread producerThread = new Thread(producer); Thread consumerThread = new Thread(consumer); producerThread.start(); consumerThread.start(); } } ``` 在上面的代码中，我们创建了一个缓冲区对象和一个生产者对象和一个消费者对象，然后将它们分别传递给两个线程，并启动这两个线程。 运行上面的代码，我们可以看到生产者和消费者交替地进行操作，生产者不断地向缓冲区中放入数据，消费者不断地从缓冲区中获取数据。如果缓冲区已满或者为空，生产者和消费者会进入等待状态，直到缓冲区中有足够的空间或者有新的数据可用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值