线程池的5种使用方式

已于 2023-03-29 23:38:59 修改
阅读量3.8k 收藏 20
点赞数 3
文章标签： java jvm 面试
于 2022-10-19 21:42:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a141210104/article/details/127416459
版权

java 中的线程

线程是调度 CPU 资源的最小单位，线程模型分为 KLT 模型与 ULT 模型，JVM 使用的 KLT 模
型，Java 线程与 OS 线程保持 1:1 的映射关系，也就是说有一个 java 线程也会在操作系统里有一个对应的线程。

Java 线程有多种生命状态 ：

  • NEW, 新建
  • RUNNABLE, 运行
  • BLOCKED, 阻塞
  • WAITING, 等待
  • TIMED_WAITING, 超时等待
  • TERMINATED，终结

池化思想

池化技术指的是提前准备一些资源，在需要时可以重复使用这些预先准备的资源。而这种资源创建的成本比较高，例如线程，大对象，数据库连接等。

所以池化技术的关键是：

  1. 被池化的对象创建成本高
  2. 提前准备
  3. 重复使用

线程池

线程池”，顾名思义就是一个线程缓存，线程是稀缺资源，如果被无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，因此 Java 中提供线程池对线程进行统一分配、调优和监控

什么时候使用线程池？

  1. 单个任务处理时间比较短
  2. 需要处理的任务数量很大

线程池优势

  1. 重用存在的线程，减少线程创建，消亡的开销，提高性能
  2. 提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。
  3. 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

线程池的使用

有常见的 5 种创建线程的方式，说是 5 种，其实就 2 种。一种是通过 Executors 工厂类提供的方法，该类提供了 4 种不同的线程池可供使用。另一类是通过 ThreadPoolExecutor 类进行自定义创建。

newCachedThreadPool

会创建一个可缓冲的线程池，线程数不够时，会一直增加到最大值(Integer.MAXVALUE)，如果线程过多，用不到了，会缓存 60 秒后销毁

private static void createCachedThreadPool() {
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                System.out.println(System.currentMillions + ":" + Thread.currentThread().getName() + ":" + index);
                sleep(2000);
            });
        }
    }

newFixedThreadPool

创建一个固定线程数量的线程池，处理不过来的任务会放到队列中，这个队列是无界队列，没有大小

private static void createFixedThreadPool() {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " " + index);
                sleep(2000);
            });
        }
    }

newScheduledThreadPool

创建一个周期性的线程池，可以定时周期性的执行任务，底层利用的是延时队列

private static void createScheduledThreadPool() {
        ScheduledExecutorService executorService = Executors.newScheduledThreadPool(3);
        System.out.println(DateUtil.now() + " 提交任务");
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.schedule(() -> {
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                sleep(2000);
            }, 3, TimeUnit.SECONDS);
        }
    }

newSingleThreadExcutor

只有一个线程的线程池

private static void createSingleThreadPool() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            executorService.execute(() -> {
                System.out.println(DateUtil.now() + " " + Thread.currentThread().getName() + " " + index);
                sleep(2000);
            });
        }
    }

上面四种是 java 为我们提供的几个便捷方法，来创建不同用途的线程池，虽然比较便捷，参数很少，减轻开发者的负担，但是也正是因为这样，并不能很好的使用与实际生产环境，比如 newFixedThreadPool ，使用的是无界队列，这在生产中是不允许的。阿里巴巴 java 开发规范中明确禁止使用上面四种方式创建线程池，而是使用下面自定义线程池的方式。

ThreadPoolExecutor 自定义线程池

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
    }

参数解释

共 7 个参数如下：

  1. corePoolSize：核心线程数，线程池中始终存活的线程数。
  2. maximumPoolSize: 最大线程数，线程池中允许的最大线程数。
  3. keepAliveTime: 存活时间，线程没有任务执行时最多保持多久时间会终止。
  4. unit: 单位，参数 keepAliveTime 的时间单位，7 种可选。
    • TimeUnit.DAYS 天
    • TimeUnit.HOURS 小时
    • TimeUnit.MINUTES 分
    • TimeUnit.SECONDS 秒
    • TimeUnit.MILLISECONDS 毫秒
    • TimeUnit.MICROSECONDS 微秒
    • TimeUnit.NANOSECONDS 纳秒
  5. workQueue: 一个阻塞队列，用来存储等待执行的任务，均为线程安全，7 种：
    • ArrayBlockingQueue 一个由数组结构组成的有界阻塞队列。
    • LinkedBlockingQueue 一个由链表结构组成的有界阻塞队列。
    • SynchronousQueue 一个不存储元素的阻塞队列，即直接提交给线程不保持它们。
    • PriorityBlockingQueue 一个支持优先级排序的无界阻塞队列。
    • DelayQueue 一个使用优先级队列实现的无界阻塞队列，只有在延迟期满时才能从中提取元素。
    • LinkedTransferQueue 一个由链表结构组成的无界阻塞队列。与 SynchronousQueue 类似，还含有非阻塞方法。
    • LinkedBlockingDeque 一个由链表结构组成的双向阻塞队列

较常用的是 LinkedBlockingQueue 和 Synchronous。线程池的排队策略与 BlockingQueue 有关

  1. threadFactory: 线程工厂，主要用来创建线程，默及正常优先级、非守护线程。

  2. handler：拒绝策略，拒绝处理任务时的策略，4 种可选，默认为 AbortPolicoy

    • AbortPolicy ` 拒绝并抛出异常。
    • CallerRunsPolicy 重试提交当前的任务，即再次调用运行该任务的 execute()方法。
    • DiscardOldestPolicy 抛弃队列头部（最旧）的一个任务，并执行当前任务。
    • DiscardPolicy 抛弃当前任务。

线程执行的顺序

  1. 当线程数小于核心线程数时，创建线程。
  2. 当线程数大于等于核心线程数，且任务队列未满时，将任务放入任务队列。
  3. 当线程数大于等于核心线程数，且任务队列已满：
  4. 若线程数小于最大线程数，创建线程。
  5. 若线程数等于最大线程数，抛出异常，拒绝任务。

优先级： 核心线程数 > 任务队列 > 最大线程数 > 拒绝任 j 务

核心线程数设置的一些经验

  • CPU 密集型: CPU 核数 + 1
  • IO 密集型: CPU 核数 * 2 + 1
  • 最佳线程数: CPU 核数 * （ 1 + （IO 耗时 / CPU 耗时））

不同线程池源码的差异

Executors 工程类提供的四种方法其实底层还是调用了 ThreadPollExecutor, 只不过是参数不同罢了

我们来看一下这 4 中方法底层的代码:

newCachedThreadPool

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

核心数为 0，最大线程数为整型最大值，允许最大空闲时间 60s, SynchronousQueue 是 BlockingQueue 的一种，所以 SynchronousQueue 是线程安全的。SynchronousQueue 和其他的 BlockingQueue 不同的是 SynchronousQueue 的 capacity 是 0。即 SynchronousQueue 不存储任何元素。即来一个任务创建一个线程。

newFixedThreadPool

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

核心线程数和最大线程数一样，允许线程永久等待，即没有设置超时时间， 队列使用的是 LinkedBlockingQueue 无界队列。

newScheduledThreadPool

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {  
    return new ScheduledThreadPoolExecutor(corePoolSize);  
}

public ScheduledThreadPoolExecutor(int corePoolSize) {  
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,  
          new DelayedWorkQueue());  
}

指定核心线程数，最大线程数是 MX_VALUE, 不设置超时时间， 任务队列是延时队列

newSingleThreadExecutor

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

核心线程数和最大线程数都是1， 不设置超时时间，使用无界队列存放任务。

通过查看以上源码发现，这4中特定的线程池都是以不同参数调用了 ThreadPoolExecutor 来实现的。

超的博客
关注
  • 3
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++11 简单实现线程池的方法
12-16
什么是线程池 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才启动。 不使用线程池有哪些弊端 创建太多线程，将会浪费一定的资源，有些线程未被充分使用。 销毁太多线程，将导致
线程池的使用ThreadPoolExecutor
qq_38667268的博客
12-12 1174
线程池意味着可以储存线程，并让池内的线程得以复用，如果池内的某一个线程执行完了，并不会直接销毁它有生命周期，可以存活一些时间，待到下一个任务来时，它会复用这个在等待中的线程，避免了再去创建线程增加的额外系统开销。CachedThreadPool∶:允许的创建线程数量为Integer .NAX_VALE，可能会创建大量的线程，我们知道每个线程默认情况下占1M的内存空间，如果线程非常多，内存资源将会被耗尽，从而导致OOM。创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。
线程池的使用
weixin_42914989的博客
05-16 3601
在使用多线程时候，都会考虑创建线程池进行线程复用。Java线程池是一种用于管理和重用线程的机制。它通过维护一组线程，并在需要时分配这些线程来执行任务，从而提高程序的性能和效率。在Java中，线程池由java.util.concurrent.ExecutorService接口表示。ExecutorService提供了一组方法，用于提交任务并管理线程池的行为。常见的实现类是ThreadPoolExecutor。要创建一个线程池，可以使用Executors类中的静态工厂方法。
常用线程池介绍
NewBie_xW的博客
10-22 825
线程池简介 1.线程池概念： 线程池是首先创建一个线程，它们的集合成为线程池。使用线程池可以很好的提升性能，线程池在启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行线程完成后，该线程不会死亡，而是返回线程池中成为空闲状态，等待执行下一个任务。 2.线程池的工作机制 2.1在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。 2.2一个线程同时只能执行一个任
Windows下一个比较完美的线程池实现和示例
03-03
Windows下一个比较完美的线程池实现和示例 本线程池提供了如下功能： 1.能根据任务个数和当前线程的多少在最小/最大线程个数之间自动调整(Vista后的系统有 SetThreadpoolThreadMaximum 等函数有类似功能)； 2.能方便的对任一任务进行取消操作，无论该任务是等待运行状态还是正在运行状态都支持(相比较而言，WaitForThreadpoolWorkCallbacks 函数只能取消尚未运行的任务)； 3.能对整个线程池进行安全的暂停、继续、停止处理 4.支持回调方式的反馈通知 5.使用模版方式实现，能方便的进行参数传递 6.在加入任务时可以设置优先级(目前尚不支持动态调整) 7.使用的是微软的基本API，能支持WinXP、Vista、Win7等各种操作系统(CreateThreadpoolWork 等只能在Vista后才能使用) 详细说明参见本人博客
线程池的使用（7种创建方法）
热门推荐
m0_48273471的博客
04-13 3万+
线程池的7种创建方法
超详细的线程池使用解析
wdj_yyds的博客
02-23 4153
前言 ​ Java 中线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序都可以使用线程池。合理的使用线程池可以带来多个好处： ​ （1）降低资源消耗。通过重复利用已创建的线程降低线程在创建和销毁时造成的消耗。 ​ （2）提高响应速度。当处理执行任务时，任务可以不需要等待线程的创建就能立刻执行。 ​ （3）提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。 1、线程池的实现原理 线程池的处理
MySQL的线程池原理学习教程
01-21
线程池是Mysql5.6的一个核心功能，对于服务器应用而言，无论是web应用服务还是DB服务，高并发请求始终是一个绕不开的话题。当有大量请求并发访问时，一定伴随着资源的不断创建和释放，导致资源利用率低，降低了服务质量。线程池是一种通用的技术，通过预先创建一定数量的线程，当有请求达到时，线程池分配一个线程提供服务，请求结束后，该线程又去服务其他请求。 通过这种方式，避免了线程和内存对象的频繁创建和释放，降低了服务端的并发度，减少了上下文切换和资源的竞争，提高资源利用效率。所有服务的线程池本质都是位了提高资源利用效率，并且实现方式也大体相同。本文主要说明Mysql线程池的实现原理。 在Mysql5
VB线程池使用
11-12
VB线程池使用
Java线程池介绍
12-22
根据摩尔定律（Moore’s law），集成电路晶体管的数量差不多每两年会翻一倍。但是晶体管数量指数级的增长不一定会导致 CPU 性能的指数级增长。处理器制造商花了很多年来提高时钟频率和指令并行。在新一代的处理器上，单线程程序的执行速率确实有所提高。但是，时钟频率不可能无限制地提高，如处理器 AMD FX-9590 的时钟频率达到5 GHz，这已经非常困难了。如今处理器制造商更喜欢采用多核处理器（multi-core processors）。拥有4核的智能手机已经非常普遍，更不用提手提电脑和台式机。结果，软件不得不采用多线程的方式，以便能够更好的使用硬件。线程池可以帮助程序员更好地利用多核 C
c/c++用一个源文件，一个头文件实现的线程池源码，包含测试代码，可运行
01-27
c/c++用一个源文件，一个头文件实现的线程池源码，包含测试代码，可运行。 说明： 1、线程池初始化时，会起多个独立线程作为线程池的work进程； 2、可修改线程池的work线程数量，需要简单修改下接口即可； 3、可设置线程的cpu亲和性绑核，就是cpu在线程调度时，会让该线程优先调度到亲和性高的cpu内核上； 4、任务加入任务队列，工作线程从任务队列里取任务执行； 5、任务队列有锁机制，是线程安全的； 6、代码是c++的，但可在以c的方式调用； 7、只依赖标准基础库和pthread库； 8、开放两个接口，调用简单；如果线程池的工作参数需要需改，可以在初始化接口里进行适当的修改，比如可配置线程池工作线程的数量；工作线程的数量建议设置到和cpu的核数一样。 9、编码方式： g++ -std=c++11 -o test test.c cppThreadWorkers.cpp -I./ -lpthread test.c：测试的c文件； cppThreadWorkers.cpp： 线程池源文件 cppThreadWorkers.h: 线程池的头文件 如果有什么问题，请私信留言。
c#线程池应用
02-24
这是一篇关于c#线程池应用的详细描述 与大家分享一下
http代理线程池的一种实现
04-21
以线程池的方式实现了一个http代理服务器
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 867
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 919
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现（C++）
m0_73969414的博客
04-23 1883
c++中string的模拟实现，面试必会知识点
线程池的创建方式有几种
01-12
线程池的创建方式有7种，其中6种是通过`Executors`创建的，1种是通过`ThreadPoolExecutor`创建的。 以下是线程池的创建方式的介绍和示例代码： 1. `Executors.newFixedThreadPool`：创建一个固定大小的线程池，可控制并发的线程数，超出的线程会在队列中等待。 ```java ExecutorService executor = Executors.newFixedThreadPool(5); ``` 2. `Executors.newCachedThreadPool`：创建一个可缓存的线程池，线程池的大小会根据需要进行自动扩展，但是在线程池中的线程空闲超过60秒后会被回收。 ```java ExecutorService executor = Executors.newCachedThreadPool(); ``` 3. `Executors.newSingleThreadExecutor`：创建一个单线程的线程池，保证所有任务按照指定顺序执行。 ```java ExecutorService executor = Executors.newSingleThreadExecutor(); ``` 4. `Executors.newScheduledThreadPool`：创建一个固定大小的线程池，可以延迟或定时执行任务。 ```java ScheduledExecutorService executor = Executors.newScheduledThreadPool(3); ``` 5. `Executors.newWorkStealingPool`：创建一个工作窃取线程池，每个线程都有自己的任务队列，当自己的任务队列为空时，会从其他线程的任务队列中窃取任务执行。 ```java ExecutorService executor = Executors.newWorkStealingPool(); ``` 6. `Executors.unconfigurableExecutorService`：创建一个不可配置的线程池，即无法修改线程池的配置参数。 ```java ExecutorService executor = Executors.unconfigurableExecutorService(executor); ``` 7. `ThreadPoolExecutor`：通过自定义参数创建线程池，可以灵活地配置线程池的大小、任务队列、拒绝策略等。 ```java ThreadPoolExecutor executor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, workQueue, handler); ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值