面试笔记——线程池

news2024/12/25 12:36:49

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

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：

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);
            @Override
            public 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();
    }

    @Override
    public 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核数：

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. 创建使用固定线程数的线程池 ——适用于任务量已知，相对耗时的任务

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

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

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolCase {

    static class FixedThreadDemo implements Runnable{
        @Override
        public 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 {
        //创建一个固定大小的线程池，核心线程数和最大线程数都是3
        ExecutorService 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)执行——适用于按照顺序执行的任务

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

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

举例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class NewSingleThreadCase {

    static int count = 0;

    static class Demo implements Runnable {
        @Override
        public void run() {
            count++;
            System.out.println(Thread.currentThread().getName() + ":" + count);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        //单个线程池，核心线程数和最大线程数都是1
        ExecutorService 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. 可缓存线程池——适合任务数比较密集，但每个任务执行时间较短的情况

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

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

举例：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolCase {

    static class Demo implements Runnable {
        @Override
        public 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_VALUE
        ExecutorService 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。

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);
}

举例

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 {
        @Override
        public 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_VALUE
        ScheduledExecutorService 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.coloradmin.cn/o/1634269.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2024年 Java 面试八股文——Redis篇

2024年 Java 面试八股文——Redis篇

目录 1、介绍下Redis Redis有哪些数据类型 难度系数&#xff1a;⭐ 2、Redis提供了哪几种持久化方式 难度系数&#xff1a;⭐ 3、Redis为什么快 难度系数&#xff1a;⭐ 4、Redis为什么是单线程的 难度系数&#xff1a;⭐ 5、Redis服务器的的内存是多大…
阅读更多...
RustGUI学习（iced）之小部件（三）：如何使用下拉列表pick_list？

RustGUI学习（iced）之小部件（三）：如何使用下拉列表pick_list？

前言 本专栏是学习Rust的GUI库iced的合集，将介绍iced涉及的各个小部件分别介绍，最后会汇总为一个总的程序。 iced是RustGUI中比较强大的一个，目前处于发展中（即版本可能会改变），本专栏基于版本0.12.1. 概述 这是本专栏的第三篇，主要讲述下拉列表pick_list部件的使用，会…
阅读更多...
c#创建新项目

c#创建新项目

确保已安装.NET Core SDK。&#xff08;visual studio installer中可安装&#xff09; cmd中先引用到文件夹目录下。 mkdir MyConsoleApp MyConsoleApp是项目文件夹的名字。 mkdir 是一个命令行工具&#xff0c;用于在文件系统中创建新的目录&#xff08;文件夹&#xff09;…
阅读更多...
【YOLO改进】换遍IoU损失函数之DIoU Loss（基于MMYOLO）

【YOLO改进】换遍IoU损失函数之DIoU Loss（基于MMYOLO）

DIoU损失函数 论文链接&#xff1a;https://arxiv.org/pdf/1911.08287 DIoU损失函数&#xff08;Distance Intersection over Union Loss&#xff09;是一种在目标检测任务中常用的损失函数&#xff0c;用于优化边界框的位置。这种损失函数是IoU损失函数的改进版&#xff0c;…
阅读更多...
windows驱动开发-电源状态(二)

windows驱动开发-电源状态(二)

Modern Standby这个特性其实很难准确的讲清楚&#xff0c;因为它是一个系统行为不是驱动功能行为&#xff0c;应用层、功能驱动、系统总线、设备本身都有不同程度的参与&#xff0c;并且它属于否决性的&#xff0c;一个系统中&#xff0c;只要有一个设备不支持Modern Standby&a…
阅读更多...
新手如何用Postman做接口自动化测试？

新手如何用Postman做接口自动化测试？

1、什么是自动化测试 把人对软件的测试行为转化为由机器执行测试行为的一种实践。 例如GUI自动化测试&#xff0c;模拟人去操作软件界面&#xff0c;把人从简单重复的劳动中解放出来&#xff0c;本质是用代码去测试另一段代码&#xff0c;属于一种软件开发工作&#xff0c;已…
阅读更多...
Q02UCPU 三菱Q系列通用型QnUCPU模块20K步40ns

Q02UCPU 三菱Q系列通用型QnUCPU模块20K步40ns

Q02UCPU 三菱Q系列通用型QnUCPU模块20K步40ns Q02UCPU外部连接, Q02UCPU可以用Q03UDVCPU替换。 Q02UCPU参数说明&#xff1a;输入输出2048点、I/O软元件点数8192、程序容量20K、基本处理速度40ns、程序内存80K、USB/RS232连接。 Q02UCPU图片 三菱通用型QnUCPU模块20K步Q02UCPU…
阅读更多...
Linux实现简单进度条（附原理解释和动图效果）

Linux实现简单进度条（附原理解释和动图效果）

1&#xff0c;行缓冲区 先看下面的代码和运行结果&#xff0c; #include<stdio.h> #include<unistd.h> int main() {printf("你好\n");sleep(3);return 0; }只是一个简单的打印“你好”然后休眠三秒&#xff0c;最后程序结束 再看下面的代码和运行结果…
阅读更多...
LT6911UXE HDMI 2.0 至双端口 MIPI DSI/CSI，带音频 龙迅方案

LT6911UXE HDMI 2.0 至双端口 MIPI DSI/CSI，带音频 龙迅方案

1. 描述LT6911UXE 是一款高性能 HDMI2.0 至 MIPI DSI/CSI 转换器&#xff0c;适用于 VR、智能手机和显示应用。HDMI2.0 输入支持高达 6Gbps 的数据速率&#xff0c;可为4k60Hz视频提供足够的带宽。此外&#xff0c;数据解密还支持 HDCP2.3。对于 MIPI DSI / CSI 输出&#xff0…
阅读更多...
Linux学习之Tcp与Udp

Linux学习之Tcp与Udp

目录 UDP Udp协议的格式 UDP的传输特性 UDP的缓冲区 基于UDP的应用层协议 TCP协议 TCP的报文格式 1.ACK确认应答机制 2.超时重传 3.TCP的链接管理机制 为什么要三次握手呢&#xff1f; 理解TIME_WAIT状态 流量控制&#xff08;可靠性效率&#xff09; 滑动窗口 拥塞…
阅读更多...
C++栈和队列模拟

C++栈和队列模拟

栈和队列所用的容器默认都为deque&#xff0c;这种容器可以看作是一种vector和list的中间性能容器。 而deque虽然头插、尾插效率很好&#xff0c;且支持 [ ] 访问&#xff08;默认容器为它的原因&#xff09;&#xff0c;但是 他的缺点也很明显&#xff1a; 1.中间插入删除会…
阅读更多...
【C++算法竞赛 · 图论】树

【C++算法竞赛 · 图论】树

目录 前言 树 树的定义 树的相关概念 树的遍历 1 先序遍历 2 中序遍历 3 后序遍历 前言 前两篇文章&#xff08;【C算法竞赛 图论】图论基础、【C算法竞赛 图论】图的存储&#xff09;中&#xff0c;介绍了图的相关概念与存储&#xff0c;还不了解的可以去补补课。 …
阅读更多...
【百度Apollo】探索自动驾驶：小白教学如何使用 Dreamview 播放数据包

【百度Apollo】探索自动驾驶：小白教学如何使用 Dreamview 播放数据包

&#x1f3ac; 鸽芷咕&#xff1a;个人主页 &#x1f525; 个人专栏: 《linux深造日志》《粉丝福利》 ⛺️生活的理想&#xff0c;就是为了理想的生活! 文章目录 引入一、Dreamview 简介二、使用 Dreamview 具体步骤步骤一&#xff1a;进入 Apollo Docker 环境步骤二&#xff…
阅读更多...
数学建模--图论最短路径基础

数学建模--图论最短路径基础

1.图的定义 学过数据结构或者离散数学的小伙伴们应该知道图的概念&#xff0c;我在这里简单的介绍一下&#xff1a; 图的概念和我们理解的是很不一样的&#xff0c;这里的图并不是我们的生活里面的图片&#xff0c;而是一种表示不同的数据之间的关系&#xff0c;例如这里的5个…
阅读更多...
hive使用hplsql进行etl或其它数据加工

hive使用hplsql进行etl或其它数据加工

参照 https://cwiki.apache.org/confluence/pages/viewpage.action?pageId59690156 http://www.hplsql.org/doc Hive HPL/SQL&#xff0c;即Hive Hybrid Procedural SQL一个开源工具&#xff0c;它为hive实现了过程性的SQL功能&#xff0c;类似Oracle的PLSQL。从hive 2.0.0开…
阅读更多...
电机控制系列模块解析（12）—— 过调制

电机控制系列模块解析（12）—— 过调制

一、过调制 电机控制中的过调制&#xff08;Overmodulation&#xff09;是指在实施脉宽调制&#xff08;PWM&#xff09;过程中&#xff0c;使调制指数&#xff08;调制深度&#xff09;超过常规线性调制区的极限&#xff0c;进入非线性调制区域。这一策略通常应用于诸如空间矢…
阅读更多...
NIO（非阻塞I/O）和IO（阻塞I/O）详解

NIO（非阻塞I/O）和IO（阻塞I/O）详解

文章目录 一、NIO&#xff08;Non-blocking I/O&#xff0c;非阻塞I/O&#xff09;1、Channel&#xff08;通道&#xff09;与Buffer&#xff08;缓冲区&#xff09;1.1、使用ByteBuffer读取文件1.2、ByteBuffer 方法1.2、ByteBuffer 结构1.3、字符串与 ByteBuffer 互转1.4 Sca…
阅读更多...
Android 音视频播放器 Demo（一）—— 视频解码与渲染

Android 音视频播放器 Demo（一）—— 视频解码与渲染

本篇作为 Android 音视频实战系列的第二篇文章&#xff0c;主要介绍视频解码与渲染过程。本系列文章目录如下&#xff1a; Android 音视频基础知识 Android 音视频播放器 Demo&#xff08;一&#xff09;—— 视频解码与渲染 Android 音视频播放器 Demo&#xff08;二&#xff…
阅读更多...
数据结构-链表练习（面试题）

数据结构-链表练习（面试题）

1&#xff0c;翻转一个单链表 建立变量cur指向第二个节点&#xff0c;curN指向cur.next&#xff0c;将第二个节点的next改为head&#xff0c;headcur这样实现&#xff0c;前两个节点顺序的翻转&#xff0c;第二个节点指向了第一个节点&#xff0c;之后cur向后移&#xff08;cu…
阅读更多...
linux中 虚拟机 修改时间 centos7

linux中 虚拟机 修改时间 centos7

方法1 &#xff1a;虚拟机内 设置 方法2 代码实现 timedatectl set-timezone "Asia/Shanghai"
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023