面试笔记——线程池

server/2024/10/22 18:28:52/

线程池的核心参数（原理）

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler)
  • corePoolSize 核心线程数目
  • maximumPoolSize 最大线程数目 = (核心线程+救急线程的最大数目)
  • keepAliveTime 生存时间 ： 救急线程的生存时间，生存时间内没有新任务，此线程资源会释放
  • unit 时间单位 ：救急线程的生存时间单位，如秒、毫秒等
  • workQueue ：当没有空闲核心线程时，新来任务会加入到此队列排队，队列满会创建救急线程执行任务
  • threadFactory 线程工厂 ：可以定制线程对象的创建，例如设置线程名字、是否是守护线程等
  • handler 拒绝策略：当所有线程都在繁忙，workQueue 也放满时，会触发拒绝策略

在这里插入图片描述
使用Demo：

java">import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;public class ThreadPoolDemo implements Runnable {public static void main(String[] args) {//创建阻塞队列LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(100);ArrayBlockingQueue<Runnable> arrayBlockingQueue = new ArrayBlockingQueue<>(5);//创建工厂ThreadFactory threadFactory = new ThreadFactory() {AtomicInteger atomicInteger = new AtomicInteger(1);@Overridepublic Thread newThread(Runnable r) {//创建线程把任务传递进去Thread thread = new Thread(r);//设置线程名称thread.setName("MyThread: "+atomicInteger.getAndIncrement());return thread;}};ThreadPoolExecutor pool  = new ThreadPoolExecutor(2,5,1,TimeUnit.SECONDS,arrayBlockingQueue,threadFactory,new ThreadPoolExecutor.DiscardOldestPolicy());for (int i = 0; i < 100; i++) {pool.submit(new ThreadPoolDemo());}pool.shutdown();}@Overridepublic void run() {//执行业务System.out.println(Thread.currentThread().getName()+" 进来了");try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"出去了");}
}

线程池中常见的阻塞队列

workQueue：当没有空闲核心线程时，新来任务会加入到此队列排队，队列满会创建救急线程执行任务。

  1. ArrayBlockingQueue：基于数组结构的有界阻塞队列，FIFO。
  2. LinkedBlockingQueue：基于链表结构的有界阻塞队列，FIFO。
  3. DelayedWorkQueue ：是一个优先级队列，它可以保证每次出队的任务都是当前队列中执行时间最靠前的
  4. SynchronousQueue：不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作。

ArrayBlockingQueue的LinkedBlockingQueue区别：在这里插入图片描述

确定核心线程数

  • IO密集型任务：核心线程数大小设置为2N+1（N为当前CPU的核数）
    • 一般来说：文件读写、DB读写、网络请求等
  • CPU密集型任务：核心线程数大小设置为N+1
    • 一般来说：计算型代码、Bitmap转换、Gson转换等

查看机器的CPU核数：

java">public static void main(String[] args) {//查看机器的CPU核数System.out.println(Runtime.getRuntime().availableProcessors());
}

参考回答：

  • 高并发、任务执行时间短 ：（ CPU核数+1 ），减少线程上下文的切换
  • 并发不高、任务执行时间长
    • IO密集型的任务 ： (CPU核数 * 2 + 1)
    • 计算密集型任务 ：（ CPU核数+1 ）
  • 并发高、业务执行时间长，解决这种类型任务的关键不在于线程池而在于整体架构的设计，看看这些业务里面某些数据是否能做缓存是第一步，增加服务器是第二步，至于线程池的设置，设置参考上一条

线程池的种类

在java.util.concurrent.Executors类中提供了大量创建连接池的静态方法，以下四种比较常见。
1. 创建使用固定线程数的线程池 ——适用于任务量已知，相对耗时的任务

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

核心线程数与最大线程数一样，没有救急线程
阻塞队列是LinkedBlockingQueue，最大容量为Integer.MAX_VALUE
举例：

java">import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class FixedThreadPoolCase {static class FixedThreadDemo implements Runnable{@Overridepublic void run() {String name = Thread.currentThread().getName();for (int i = 0; i < 2; i++) {System.out.println(name + ":" + i);}}}public static void main(String[] args) throws InterruptedException {//创建一个固定大小的线程池，核心线程数和最大线程数都是3ExecutorService executorService = Executors.newFixedThreadPool(3);for (int i = 0; i < 5; i++) {executorService.submit(new FixedThreadDemo());Thread.sleep(10);}executorService.shutdown();}}

运行结果：

pool-1-thread-1:0
pool-1-thread-1:1
pool-1-thread-2:0
pool-1-thread-2:1
pool-1-thread-3:0
pool-1-thread-3:1
pool-1-thread-1:0
pool-1-thread-1:1
pool-1-thread-2:0
pool-1-thread-2:1

2. 单线程化的线程池，它只会用唯一的工作线程来执行任 务，保证所有任务按照指定顺序(FIFO)执行——适用于按照顺序执行的任务

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

核心线程数和最大线程数都是1
阻塞队列是LinkedBlockingQueue，最大容量为Integer.MAX_VALUE

举例：

java">import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class NewSingleThreadCase {static int count = 0;static class Demo implements Runnable {@Overridepublic void run() {count++;System.out.println(Thread.currentThread().getName() + ":" + count);}}public static void main(String[] args) throws InterruptedException {//单个线程池，核心线程数和最大线程数都是1ExecutorService exec = Executors.newSingleThreadExecutor();for (int i = 0; i < 10; i++) {exec.execute(new Demo());Thread.sleep(5);}exec.shutdown();}}

运行结果:

pool-1-thread-1:1
pool-1-thread-1:2
pool-1-thread-1:3
pool-1-thread-1:4
pool-1-thread-1:5
pool-1-thread-1:6
pool-1-thread-1:7
pool-1-thread-1:8
pool-1-thread-1:9
pool-1-thread-1:10

3. 可缓存线程池——适合任务数比较密集，但每个任务执行时间较短的情况

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

核心线程数为0
最大线程数是Integer.MAX_VALUE
阻塞队列为SynchronousQueue:不存储元素的阻塞队列，每个插入操作都必须等待一个移出操作。

举例：

java">import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;public class CachedThreadPoolCase {static class Demo implements Runnable {@Overridepublic void run() {String name = Thread.currentThread().getName();try {//修改睡眠时间，模拟线程执行需要花费的时间Thread.sleep(100);System.out.println(name + "执行完了");} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) throws InterruptedException {//创建一个缓存的线程，没有核心线程数，最大线程数为Integer.MAX_VALUEExecutorService exec = Executors.newCachedThreadPool();for (int i = 0; i < 10; i++) {exec.execute(new Demo());Thread.sleep(1);}exec.shutdown();}}

运行结果：

pool-1-thread-1执行完了
pool-1-thread-2执行完了
pool-1-thread-3执行完了
pool-1-thread-4执行完了
pool-1-thread-5执行完了
pool-1-thread-6执行完了
pool-1-thread-7执行完了
pool-1-thread-8执行完了
pool-1-thread-9执行完了
pool-1-thread-10执行完了

4. 提供了“延迟”和“周期执行”功能的ThreadPoolExecutor。

java">public ScheduledThreadPoolExecutor(int corePoolSize) {super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,new DelayedWorkQueue());
}
public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory) {super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory);
}
public ScheduledThreadPoolExecutor(int corePoolSize,RejectedExecutionHandler handler) {super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), handler);
}
public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory,RejectedExecutionHandler handler) {super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS, new DelayedWorkQueue(), threadFactory, handler);
}

举例

java">import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;public class ScheduledThreadPoolCase {static class Task implements Runnable {@Overridepublic void run() {try {String name = Thread.currentThread().getName();System.out.println(name + ", 开始：" + new Date());Thread.sleep(1000);System.out.println(name + ", 结束：" + new Date());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) throws InterruptedException {//按照周期执行的线程池，核心线程数为2，最大线程数为Integer.MAX_VALUEScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);System.out.println("程序开始：" + new Date());/*** schedule 提交任务到线程池中* 第一个参数：提交的任务* 第二个参数：任务执行的延迟时间* 第三个参数：时间单位*/scheduledThreadPool.schedule(new Task(), 0, TimeUnit.SECONDS);scheduledThreadPool.schedule(new Task(), 1, TimeUnit.SECONDS);scheduledThreadPool.schedule(new Task(), 5, TimeUnit.SECONDS);Thread.sleep(5000);// 关闭线程池scheduledThreadPool.shutdown();}}

运行结果：

程序开始：Mon Apr 29 22:26:18 CST 2024
pool-1-thread-1, 开始：Mon Apr 29 22:26:18 CST 2024
pool-1-thread-2, 开始：Mon Apr 29 22:26:19 CST 2024
pool-1-thread-1, 结束：Mon Apr 29 22:26:19 CST 2024
pool-1-thread-2, 结束：Mon Apr 29 22:26:20 CST 2024
pool-1-thread-1, 开始：Mon Apr 29 22:26:23 CST 2024
pool-1-thread-1, 结束：Mon Apr 29 22:26:24 CST 2024

综上：
newFixedThreadPool：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待
newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任 务，保证所有任务按照指定顺序(FIFO)执行
newCachedThreadPool：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
newScheduledThreadPool：可以执行延迟任务的线程池，支持定时及周期性任务执行

为什么不使用Excutors创建线程池

参考阿里开发手册《Java开发手册-嵩山版》
在这里插入图片描述
ps：OOM是指内存溢出。
最后，建议根据计算机的条件使用ThreadPoolExecutor创建线程池（突然感觉上一节白学了，唉~）。


http://www.ppmy.cn/server/24205.html

相关文章

manim

manim

当安装Manim时&#xff0c;首先需要安装Manim库本身&#xff0c;然后安装一些依赖库和工具&#xff0c;以确保Manim可以正常运行。以下是合并后的安装步骤&#xff1a; 安装Manim和依赖的步骤&#xff1a; 1. 安装Manim 首先&#xff0c;安装Manim库。你可以使用以下命令在终…
阅读更多...
如何下载钉钉群直播回放：完整步骤解析

如何下载钉钉群直播回放：完整步骤解析

在当今快节奏的商业和教育环境中&#xff0c;钉钉群直播已经成为了沟通和学习的重要工具。直播结束后&#xff0c;很多观众都希望回顾内容&#xff0c;但却不知如何开始。如果你错过了实时直播&#xff0c;或者只是想再次观看精彩的演讲和讨论&#xff0c;那么下载钉钉群直播回…
阅读更多...
Python爬虫技术与数据可视化：Numpy、pandas、Matplotlib的黄金组合

Python爬虫技术与数据可视化：Numpy、pandas、Matplotlib的黄金组合

前言 在当今信息爆炸的时代&#xff0c;数据已成为企业决策和发展的关键。而互联网作为信息的主要来源&#xff0c;网页中蕴含着大量的数据等待被挖掘。Python爬虫技术和数据可视化工具的结合&#xff0c;为我们提供了一个强大的工具箱&#xff0c;可以帮助我们从网络中抓取数…
阅读更多...
【多级缓存】多级缓存OpenResty，Canal，nginx本地缓存

【多级缓存】多级缓存OpenResty，Canal，nginx本地缓存

多级缓存 安装OpenRestyOpenResty入门OpenResty获取请求参数OpenResty向tomcat服务器发送请求 在nginx与tomcat端之间添加redis缓存Redis本地缓存缓存同步缓存同步策略基于Canal的异步通知安装Canal Canal客户端 安装OpenResty OpenResty是一个基于 Nginx的高性能 Web 平台&am…
阅读更多...
电力能源箱3D可视化：开启智慧能源管理新篇章

电力能源箱3D可视化：开启智慧能源管理新篇章

随着科技的不断进步&#xff0c;电力能源箱的管理与维护逐渐向着智能化、可视化的方向发展。3D可视化技术的崛起&#xff0c;不仅极大地提升了能源管理的效率&#xff0c;更以其直观、生动的特点&#xff0c;引领着电力能源管理领域迈入了一个全新的时代。 电力能源箱作为电力系…
阅读更多...
RAGFlow：引领OCR与文档解析技术革新的下一代RAG引擎

RAGFlow：引领OCR与文档解析技术革新的下一代RAG引擎

引言 在人工智能的蓬勃发展浪潮中，检索增强生成（RAG）技术凭借其独特优势，迅速成为研究和应用的焦点。RAG技术巧妙地将大型语言模型（LLMs）的卓越生成能力与高效的信息检索系统相结合，为用户带来前所未有的交互体验。然而，随着技术的深入应用，一系列挑战也逐渐浮出水面…
阅读更多...
【Vue3】openlayers加载瓦片地图并手动标记坐标点

【Vue3】openlayers加载瓦片地图并手动标记坐标点

目录 一、创建Vue3项目 二、openlayers加载瓦片地图&#xff08;引js文件版&#xff09; 2.1 将以下的文件复制到public下 2.2 index.html引入ol脚本 2.3 删除项目自带的HelloWorld.vue&#xff0c;创建Map.vue 2.4 编码Map.vue 2.5 修改App.vue 2.6 启动项目测试 三、…
阅读更多...
探索Jellyfin：支持Android的自由开源的媒体服务器平台

探索Jellyfin：支持Android的自由开源的媒体服务器平台

探索Jellyfin&#xff1a;支持Android的自由开源的媒体服务器平台 I. 简介 A. 什么是Jellyfin&#xff1f; Jellyfin是一个自由开源的媒体服务器平台&#xff0c;旨在让用户能够自主管理和流式传输他们的媒体内容。与许多闭源的商业媒体服务器解决方案不同&#xff0c;Jelly…
阅读更多...
最新文章

Copyright @ 2022~2023