java 线程工厂_Java并发编程:Java的四种线程池的使用,以及自定义线程工厂
引言
通过前面的文章,我们学习了Executor框架中的核心类ThreadPoolExecutor ,对于线程池的核心调度机制有了一定的了解,并且成功使用ThreadPoolExecutor 创建了线程池。
而在Java中,除了ThreadPoolExecutor ,Executor框架中还提供了四种线程池,这四种线程池都是直接或间接配置ThreadPoolExecutor的参数实现的,对于ThreadPoolExecutor类不熟悉的读者可以参考Java并发编程:Java线程池核心ThreadPoolExecutor的使用和原理分析
四种线程池
四种线程池分别是:newCachedThreadPool、newFixedThreadPool 、newScheduledThreadPool 和newSingleThreadExecutor ,下面对这几个线程池一一讲解。
newCachedThreadPool:可缓存的线程池
源码:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue());
}
newCachedThreadPool的方法中是返回一个ThreadPoolExecutor实例,从源码中可以看出该线程池的特点:
1、该线程池的核心线程数量是0,线程的数量最高可以达到Integer 类型最大值;
2、创建ThreadPoolExecutor实例时传过去的参数是一个SynchronousQueue实例,说明在创建任务时,若存在空闲线程就复用它,没有的话再新建线程。
3、线程处于闲置状态超过60s的话,就会被销毁。
用法:
public static void main(String[] args) {
//定义ExecutorService实例
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//调用execute方法
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread() + ":" + index);
}
});
}
}
上面的代码因为每次循环都是隔一秒执行,这个时间足够之前的线程工作完毕,并在新循环中复用这个线程,程序的运行结果如下:
Thread[pool-1-thread-1,5,main]:0
Thread[pool-1-thread-1,5,main]:1
Thread[pool-1-thread-1,5,main]:2
Thread[pool-1-thread-1,5,main]:3
Thread[pool-1-thread-1,5,main]:4
Thread[pool-1-thread-1,5,main]:5
Thread[pool-1-thread-1,5,main]:6
Thread[pool-1-thread-1,5,main]:7
Thread[pool-1-thread-1,5,main]:8
Thread[pool-1-thread-1,5,main]:9
newFixedThreadPool:定长线程池
源码:
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue());
}
线程池特点:
1、线程池的最大线程数等于核心线程数,并且线程池的线程不会因为闲置超时被销毁。
2、使用的列队是LinkedBlockingQueue,表示如果当前线程数小于核心线程数,那么即使有空闲线程也不会复用线程去执行任务,而是创建新的线程去执行任务。如果当前执行任务数量大于核心线程数,此时再提交任务就在队列中等待,直到有可用线程。
用法:
public static void main(String[] args) {
ExecutorService cachedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread() + ":" + index);
}
});
}
}
定义一个线程数为3的线程池,循环10次执行,可以发现运行的线程永远只有三个,结果如下:
Thread[pool-1-thread-1,5,main]:0
Thread[pool-1-thread-2,5,main]:1
Thread[pool-1-thread-3,5,main]:2
Thread[pool-1-thread-1,5,main]:3
Thread[pool-1-thread-2,5,main]:4
Thread[pool-1-thread-3,5,main]:5
Thread[pool-1-thread-1,5,main]:6
Thread[pool-1-thread-2,5,main]:7
Thread[pool-1-thread-3,5,main]:8
Thread[pool-1-thread-1,5,main]:9
newSingleThreadExecutor:单线程线程池
源码:
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue()));
}
从源码就可以看出,该线程池基本就是只有一个线程数的newFixedThreadPool,它只有一个线程在工作,所有任务按照指定顺序执行。
用法:
和newFixedThreadPool类似,只是一直只有一个线程在工作,这里就不贴代码了。
newScheduledThreadPool:支持定时的定长线程池
源码:
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
new DelayedWorkQueue());
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
newScheduledThreadPool的方法不是直接返回一个ThreadPoolExecutor实例,而是通过有定时功能的ThreadPoolExecutor,也就是ScheduledThreadPoolExecutor 来返回ThreadPoolExecutor实例,从源码中可以看出:
1、该线程池可以设置核心线程数量,最大线程数与newCachedThreadPool一样,都是Integer.MAX_VALUE。
2、该线程池采用的队列是DelayedWorkQueue,具有延迟和定时的作用。
用法:
public static void main(String[] args) {
ExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
//延迟3秒执行,只执行一次
((ScheduledExecutorService) scheduledThreadPool).schedule(new Runnable() {
@Override
public void run() {
System.out.println("延迟========");
}
},3,TimeUnit.SECONDS);
//延迟1秒后每隔两秒执行一次
((ScheduledExecutorService) scheduledThreadPool).scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("执行============");
}
},1,2,TimeUnit.SECONDS); //单位是秒
}
自定义ThreadFactory
四种线程池的使用就说到这里了,值得说明的是,除了上面的参数外,Executors类中还给这四种线程池提供了可传ThreadFactory的重载方法,以下是它们的源码:
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(),
threadFactory));
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue(),
threadFactory);
}
public static ScheduledExecutorService newScheduledThreadPool(
int corePoolSize, ThreadFactory threadFactory) {
return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue(),
threadFactory);
}
ThreadFactory是一个接口类,也就是我们经常说的线程工厂,只有一个方法,可以用于创建线程:
Thread newThread(Runnable r);
默认情况下,ThreadPoolExecutor构造器传入的ThreadFactory 参数是Executors类中的defaultThreadFactory(),相当于一个线程工厂,帮我们创建了线程池中所需的线程。
除此之外,我们也可以自定义ThreadFactory,并根据自己的需要来操作线程,下面是实例代码:
public static void main(String[] args) {
ExecutorService service = new ThreadPoolExecutor(5, 5, 0L, TimeUnit.MILLISECONDS,
new SynchronousQueue(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
System.out.println("我是线程" + r);
return t;
}
}
);
//用lambda表达式编写方法体中的逻辑
Runnable run = () -> {
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "正在执行");
} catch (InterruptedException e) {
e.printStackTrace();
}
};
for (int i = 0; i < 5; i++) {
service.submit(run);
}
//这里一定要做关闭
service.shutdown();
}
运行代码后,控制行会输出五行 “我是线程java.util.concurrent.ThreadPoolExecutor。。。。。”的信息,也证明了我们自定义的ThreadFactory起到了作用。
java 线程工厂_Java并发编程:Java的四种线程池的使用,以及自定义线程工厂相关推荐
- java queue 线程安全_java并发编程之线程安全方法
线程安全的实现方法,包含如下方式 一, 互斥同步 使用互斥锁的方式. 举个栗子 synchronized,最常用的同步实现方案, ReentrantLock,java并发包中工具,后续介绍. 互斥同步 ...
- java线程状态_java并发编程之线程状态
java线程中,线程状态是如何转换的呢?这一次我们一起来学习下. 线程状态: NEW: 线程创建之后,还没有启动.这时候它的状态就是NEW RUNNABLE: 正在Java虚拟机下跑任务的线程的状态. ...
- java 多线程 任务队列_Java并发编程线程池任务队列
类ThreadPoolExecutor最常使用的构造方法是: ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliv ...
- java 延迟初始化_Java并发编程——延迟初始化占位类模式
--仅作笔记使用,内容多摘自<java并发编程实战> 在并发编程中,如果状态变量仅在单个线程中初始化和使用,自然是线程安全的,但一旦涉及到线程间的数据交互,如何声明一个用于多线程的单例状态 ...
- java executor 异步_Java并发编程11-异步执行框架Executor
1 Executor框架的简介 1.5后引入的Executor框架的最大优点是把任务的提交和执行解耦.要执行任务的人只需把Task描述清楚,然后提交即可.这个Task是怎么被执行的,被谁执行的,什么时 ...
- java投票锁_Java并发编程锁之独占公平锁与非公平锁比较
Java并发编程锁之独占公平锁与非公平锁比较 公平锁和非公平锁理解: 在上一篇文章中,我们知道了非公平锁.其实Java中还存在着公平锁呢.公平二字怎么理解呢?和我们现实理解是一样的.大家去排队本着先来 ...
- java lock 对象_Java并发编程锁系列之ReentrantLock对象总结
Java并发编程锁系列之ReentrantLock对象总结 在Java并发编程中,根据不同维度来区分锁的话,锁可以分为十五种.ReentranckLock就是其中的多个分类. 本文主要内容:重入锁理解 ...
- java计算时间差_JAVA并发编程三大Bug源头(可见性、原子性、有序性),彻底弄懂...
原创声明:本文转载自公众号[胖滚猪学编程] 某日,胖滚猪写的代码导致了一个生产bug,奋战到凌晨三点依旧没有解决问题.胖滚熊一看,只用了一个volatile就解决了.并告知胖滚猪,这是并发编程导致的 ...
- java社区活跃度_Java并发编程-活跃度问题
在讲问题前,我先说明一下什么是活跃度? 一个并发应用及时执行的能力称作活跃度. 我主要讲死锁问题,顺带介绍一下饥饿,弱响应性和活锁. 死锁 死锁这个词大家都听过,我先来罗列一下产生死锁的四个必要条件: ...
最新文章
- Datawhale组队学习周报(第003周)
- 微服务接入oauth2_SpringCloud微服务实战系列(十九)Ouath2在真实场景中的应用之客户端接入(第一种写法)...
- 正确理解ContentPresenter
- python函数应用实例_【Python 第22课】 函数应用示例
- 安卓系统上的远程 JS 调试 Remote JavaScript Debugging on Android
- python 手动拼接json数据
- 获取电脑系统当前时间
- P NP NPC NP hard
- 【运动学】基于matlab GUI模拟小球自由落体【含Matlab源码 1630期】
- J2EE基础教程(3):Spring框架
- 大数据概念思维导图_大数据技术思维导图
- android 地址json文件,Android访问assets本地json文件的方法
- [bzoj1406][数论]密码箱
- html 显示动态时间
- 这些惹人嫌的说话方式,你有吗?
- 一起来学linux:网络命令
- ctfshow (ssrf学习和实践)
- 微信企业号开发-如何建立连接
- 最新亲测仿悬赏猫牛帮任务平台源码完美运营+支持封装APP
- css 控制 段落 超出三行的部分显示...