非常适合新手学生的Java线程池超详细分析
作者:摸鱼打酱油 发布时间:2023-03-03 11:59:54
线程池的好处
可以实现线程的复用,避免重新创建线程和销毁线程。创建线程和销毁线程对CPU的开销是很大的。
可以限制最大可创建的线程数,可根据自己的机器性能动态调整线程池参数,提高应用性能。
提供定时执行、并发数控制等功能。
统一管理线程。
创建线程池的五种方式
1:缓存线程池(不推荐)
2:固定容量线程池(不推荐)
3:单个线程池(不推荐)
4:定时任务线程池(不推荐)
5:通过ThreadPoolExecutor构造方法创建线程池(阿里巴巴开发手册十分推荐)
前面4种创建线程池的方式都是通过Executors的静态方法来创建。
缓存线程池CachedThreadPool
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int finalI = i;
executorService.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
}
});
}
为什么不推荐使用缓存线程池?
源码分析
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, 2147483647, 60L, TimeUnit.SECONDS, new SynchronousQueue());
}
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, Executors.defaultThreadFactory(), defaultHandler);
}
通过上面两个代码片段,我们可以看出CachedThreadPool的maximumPoolSize为Integer的最大值2147483647,相当于可以无限的创建线程,而创建线程是需要内存的,这样就会造成内存溢出,而且一般的机器也没用那么大的内存给它创建这么大量的线程。
固定容量线程池FixedThreadPool
newFixedThreadPool(int num),num就是我们要指定的固定线程数量
ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
final int finalI = i;
executorService.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
}
});
}
输出:
pool-1-thread-5<thread->run>4
pool-1-thread-4<thread->run>3
pool-1-thread-5<thread->run>5
pool-1-thread-3<thread->run>2
pool-1-thread-3<thread->run>8
pool-1-thread-3<thread->run>9
pool-1-thread-2<thread->run>1
pool-1-thread-1<thread->run>0
pool-1-thread-5<thread->run>7
pool-1-thread-4<thread->run>6
可以看出起到了线程的复用。
为什么FixedThreadPool是固定线程池?
源码分析
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue());
}
通过这个源码可以看出,核心线程数(corePoolSize)和最大线程数(maximumPoolSize)都为nThreads,因为只有这样,线程池才不会进行扩容,线程数才固定。
单个线程池SingleThreadExecutor
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int finalI = i;
executorService.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
}
});
}
为什么SingleThreadExecutor只含有一个线程?
源码分析
public static ExecutorService newSingleThreadExecutor() {
return new Executors.FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue()));
}
通过这个源码可以看出,核心线程数(corePoolSize)和最大线程数(maximumPoolSize)都为1,所以它只含有一个线程。
定时任务线程池ScheduledThreadPool
int initDelay=10; //初始化延时
int period=1;//初始化延迟过了之后,每秒的延时
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"<thread->run>");
}
},initDelay,period, TimeUnit.SECONDS);
这段代码的效果是:程序运行之后等10秒,然后输出第一次结果,之后每隔1秒输出一次结果。
为什么不推荐使用ScheduledThreadPool?
源码分析
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, 2147483647, 10L, TimeUnit.MILLISECONDS, new ScheduledThreadPoolExecutor.DelayedWorkQueue());
}
可以看出ScheduledThreadPool的最大线程数(maximumPoolSize)为Integer的最大值2147483647,相当于可以无限的创建线程,而创建线程是需要内存的,这样就会造成内存溢出,而且一般的机器也没用那么大的内存给它创建这么大量的线程。
ThreadPoolExecutor创建线程池(十分推荐)
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
2L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 12; i++) {
final int finalI = i;
threadPoolExecutor.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
}
});
}
ThreadPoolExecutor的七个参数详解
public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
}
corePoolSize:核心线程数。这些线程一旦被创建不会被销毁,是一直存在的。线程池默认是没有线程的,当有任务到来了,就会通过ThreadFactory去创建线程,并一直存在。
maximumPoolSize:最大线程数。非核心线程数=maximumPoolSize-corePoolSize,非核心线程数其实就是可扩容的线程数,可能会被销毁。
keepAliveTime:非核心线程的空闲存活时间。当通过扩容生成的非核心线程数在keepAliveTime这个时间后还处于空闲状态,则会销毁这些非核心线程。
unit:keepAliveTime的时间单位,例如:秒
workQueue:等待区。当来了>corePoolSize的任务时会把任务存放在workQueue这个阻塞队列中,等待其他线程处理。
threadFactory:线程工厂。创建线程的一种方式。
handler:拒绝策略。当来了>最大线程数+workQueue的容量则会执行拒绝策略
workQueue
ArrayBlockingQueue:有界阻塞队列。队列有大小限制,当容量超过时则会触发扩容或者拒绝策略。
public ArrayBlockingQueue(int capacity) {
this(capacity, false);
}
LinkedBlockingQueue: * 阻塞队列,队列无大小限制,可能会造成内存溢出。
public LinkedBlockingQueue() {
this(2147483647);
}
handler
AbortPolicy:直接抛异常
public static class AbortPolicy implements RejectedExecutionHandler {
public AbortPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() + " rejected from " + e.toString());
}
}
DiscardPolicy:不作任何操作。默默丢弃任务
public static class DiscardPolicy implements RejectedExecutionHandler {
public DiscardPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
DiscardOldestPolicy:丢掉存在时间最长的任务
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
public DiscardOldestPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}
CallerRunsPolicy:让提交任务的线程去处理任务
public static class CallerRunsPolicy implements RejectedExecutionHandler {
public CallerRunsPolicy() {
}
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}
threadFactory
ThreadFactory threadFactory = Executors.defaultThreadFactory();
threadFactory.newThread(new Runnable() {
@Override
public void run() {
System.out.println("threadFactory");
}
}).start();
如何触发拒绝策略和线程池扩容?
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20,
2L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5),
Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
for (int i = 0; i < 26; i++) { //并发数26
final int finalI = i;
threadPoolExecutor.execute(new Runnable() {
public void run() {
System.out.println(Thread.currentThread().getName()+"<thread->run>"+ finalI);
}
});
}
/**
* 核心线程数=10,最大线程数=20,故可扩容线程数=20-10
* BlockingQueue的大小为5,故等待区的大小为5,也就是当并发数<=核心线程数+5不会扩容,并发数大于16才会扩容
*
* 触发扩容:并发数>核心线程数+阻塞队列的大小
* 对于这段代码,如果来了26个并发,10个并发会被核心线程处理,5个会在等待区,剩下11个会因为等待区满了而触发扩容
* 因为这里最多能够扩容10个,这里却是11个,所以会触发拒绝策略
*/
为什么这段代码会触发拒绝策略
对于这段代码,如果来了26个并发,10个并发会被核心线程处理,5个会在等待区,剩下11个会因为等待区满了而触发扩容,但是又因为因为这里最多能够扩容10个,这里却是11个,所以会触发拒绝策略。
怎么触发扩容
触发扩容:并发数>核心线程数(corePoolSize)+阻塞队列(workQueue)的大小
使用Java纯手写一个线程池
下期文章链接https://www.jb51.net/article/241589.htm
来源:https://blog.csdn.net/weixin_50071998/article/details/123552661
猜你喜欢
- SpringAOP的介绍:传送门demo介绍主要通过自定义注解,使用SpringAOP的环绕通知拦截请求,判断该方法是否有自定义注解,然后判
- 本文实例讲述了Java获得当前时间前指定几个小时具体时间的方法。分享给大家供大家参考,具体如下:package getBeforeHourD
- 一、引言90坦克大战,很经典的一款游戏,当年与小伙伴一人一个手柄,搬上小板凳坐在电视机前,身体时不时跟随手柄摇晃着,时而表情严肃、眉头紧锁,
- Android ListView的Item点击效果的定制
- 1.引言在开发中,拖放是一种比较常见的手势操作,使用它能够让应用的交互更加地便捷和友好,本文将简要介绍如何为Android中的View添加拖
- C语言的printf函数,参数的数量可以是可变的。使用 va_start 和 va_end 实现。C++中,实现参数可变,可以用
- 开发环境使用jdk1.8.0_60,把springboot 项目打成war包后,部署到apache-tomcat-7.0.68时报错如下,换
- 开发 Web 应用的思路实现一个简单的 JSP/Servlet。搭建创建 Web 应用工程的环境。创建 Web 应用工程。Web 应用工程的
- Kotlin开发Android应用实例详解我们简单的知道了Kotlin这门新语言的优势,也接触了一些常见的语法及其简单的使用,相信你会对它有
- 定义jdk8发布新特性中,lambda是一大亮点之一。lambda表达式能够简化我们对数据的操作,减少代码量,大大提升我们的开发效率。Lam
- 用java来打包文件生成压缩文件,有两个地方会出现乱码:内容的中文乱码问题:修改sun的源码。使用开源的类库org.apache.tools
- 最近在学习AngularJS的知识,收获不少,不过因为自己平时工作时开发都是用的freemarker+springmvc来做的页面数据交互,
- mybatis in foreach 双层嵌套需求:根据角色id,返回角色名称,入参是List<List> 类型的二维数组,需要
- 无论是我们在使用word还是记事本,系统都会为我们提供撤销的功能,这几乎是人人都会使用到的功能,而在我们实际开发中,会不会存在一个很复杂的对
- 一、简介约瑟夫问题(有时也称为约瑟夫斯置换,是一个出现在计算机科学和数学中的问题。在计算机编程的算法中,类似问题又称为约瑟夫环。又称“丢手绢
- 若代理类在程序运行前就已经存在,那么这种代理方式被成为 静态代理 ,这种情况下的代理类通常都是我们在Java代码中定义的。 通常情况下, 静
- Java Resource路径首先一点很重要,Java中不存在标准的相对路径,各种相对路径取资源的方式都是基于某种规则转化为绝
- SpringMVC在接收集合请求参数时,需要在Controller方法的集合参数里前添加@RequestBody,而@RequestBody
- 在Java的线程执行中,不管是直接继承Thread的方式,还是实现Runnable接口的方式,都不会获取到线程执行的返回结果。这样如果线程在
- 本文实例讲述了Java数组高级算法与Arrays类常见操作。分享给大家供大家参考,具体如下:冒泡排序冒泡排序原理冒泡排序代码:package