目录
1.7.2 定时线程池(ScheduledThreadPool )
1.7.3 可缓存线程池(CachedThreadPool)
1.7.4 单线程化线程池(SingleThreadExecutor)
1.线程池介绍
1.1 为什么使用线程池
过于频繁的创建/销毁线程,会影响处理效率和运行速度,消耗系统资源,降低系统稳定性,一不小心搞崩公司系统直接下岗,而使用线程池可以避免这些问题,稳住饭碗,并且可以对线程这个稀缺资源进行管理、调优与监控
1.2 线程池的优势
(1)降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
(2)提高响应速度。当任务到达时,任务可以不需要等到线程创建就能立即执行。
(3)提高线程的可管理性。线程是稀缺资源,如果无限制的创建,不仅会消耗系统资源,还会降低系统的稳定性,使用线程池可以进行统一的分配,调优和监控
1.3 线程池的常用参数
线程池的真正实现类是 ThreadPoolExecutor,其构造方法有如下4种:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
Executors.defaultThreadFactory(), handler);
}
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
if (corePoolSize < 0 ||
maximumPoolSize <= 0 ||
maximumPoolSize < corePoolSize ||
keepAliveTime < 0)
throw new IllegalArgumentException();
if (workQueue == null || threadFactory == null || handler == null)
throw new NullPointerException();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
corePoolSize(必需):核心线程数。默认情况下,核心线程会一直存活,但是当将 allowCoreThreadTimeout 设置为 true 时,核心线程也会超时回收。
maximumPoolSize(必需):线程池所能容纳的最大线程数。当活跃线程数达到该数值后,后续的新任务将会阻塞。
keepAliveTime(必需):线程闲置超时时长。如果超过该时长,非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时,核心线程也会超时回收。
unit(必需):指定 keepAliveTime 参数的时间单位。常用的有:TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS(秒)、TimeUnit.MINUTES(分)。
workQueue(必需):任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。
threadFactory(可选):线程工厂。用于指定为线程池创建新线程的方式。
handler(可选):拒绝策略。当达到最大线程数时需要执行的饱和策略。
1.4 线程池工作原理
1.5 线程池参数
1.5.1 任务队列(workQueue)
任务队列是基于阻塞队列实现的,即采用生产者消费者模式,在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现:
ArrayBlockingQueue:一个由数组结构组成的有界阻塞队列(数组结构可配合指针实现一个环形队列)。
LinkedBlockingQueue: 一个由链表结构组成的有界阻塞队列,在未指明容量时,容量默认为 Integer.MAX_VALUE。
PriorityBlockingQueue: 一个支持优先级排序的无界阻塞队列,对元素没有要求,可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。跟时间没有任何关系,仅仅是按照优先级取任务。
DelayQueue:类似于PriorityBlockingQueue,是二叉堆实现的无界优先级阻塞队列。要求元素都实现 Delayed 接口,通过执行时延从队列中提取任务,时间没到任务取不出来。
SynchronousQueue: 一个不存储元素的阻塞队列,消费者线程调用 take() 方法的时候就会发生阻塞,直到有一个生产者线程生产了一个元素,消费者线程就可以拿到这个元素并返回;生产者线程调用 put() 方法的时候也会发生阻塞,直到有一个消费者线程消费了一个元素,生产者才会返回。
LinkedBlockingDeque: 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO(先进先出),也可以像栈一样 FILO(先进后出)。
LinkedTransferQueue: 它是ConcurrentLinkedQueue、LinkedBlockingQueue 和 SynchronousQueue 的结合体,但是把它用在 ThreadPoolExecutor 中,和 LinkedBlockingQueue 行为一致,但是是无界的阻塞队列。
注意有界队列和无界队列的区别:如果使用有界队列,当队列饱和时并超过最大线程数时就会执行拒绝策略;而如果使用无界队列,因为任务队列永远都可以添加任务,所以设置 maximumPoolSize 没有任何意义
1.5.2 线程工厂(threadFactory)
线程工厂指定创建线程的方式,需要实现 ThreadFactory 接口,并实现 newThread(Runnable r) 方法。该参数可以不用指定,Executors 框架已经为我们实现了一个默认的线程工厂
/**
* The default thread factory.
*/
private static class DefaultThreadFactory implements ThreadFactory {
private static final AtomicInteger poolNumber = new AtomicInteger(1);
private final ThreadGroup group;
private final AtomicInteger threadNumber = new AtomicInteger(1);
private final String namePrefix;
DefaultThreadFactory() {
SecurityManager s = System.getSecurityManager();
group = (s != null) ? s.getThreadGroup() :
Thread.currentThread().getThreadGroup();
namePrefix = "pool-" +
poolNumber.getAndIncrement() +
"-thread-";
}
public Thread newThread(Runnable r) {
Thread t = new Thread(group, r,
namePrefix + threadNumber.getAndIncrement(),
0);
if (t.isDaemon())
t.setDaemon(false);
if (t.getPriority() != Thread.NORM_PRIORITY)
t.setPriority(Thread.NORM_PRIORITY);
return t;
}
}
1.6 拒绝策略(handler)
当线程池的线程数达到最大线程数时,需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口,并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略:
AbortPolicy(默认):丢弃任务并抛出 RejectedExecutionException 异常。
CallerRunsPolicy:由调用线程处理该任务。
DiscardPolicy:丢弃任务,但是不抛出异常。可以配合这种模式进行自定义的处理方式。
DiscardOldestPolicy:丢弃队列最早的未处理任务,然后重新尝试执行任务。
1.7 Executors功能线程池
嫌上面使用线程池的方法太麻烦?其实Executors已经为我们封装好了 4 种常见的功能线程池,如下:
定长线程池(FixedThreadPool)
定时线程池(ScheduledThreadPool )
可缓存线程池(CachedThreadPool)
单线程化线程池(SingleThreadExecutor)
1.7.1 定长线程池(FixedThreadPool)
- 特点:只有核心线程,线程数量固定,执行完立即回收,任务队列为链表结构的有界队列。
- 应用场景:控制线程最大并发数。
使用示例:
// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
System.out.println("执行任务啦");
}
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);
1.7.2 定时线程池(ScheduledThreadPool )
- 特点:核心线程数量固定,非核心线程数量无限,执行完闲置 10ms 后回收,任务队列为延时阻塞队列。
- 应用场景:执行定时或周期性的任务。
使用示例:
// 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
System.out.println("执行任务啦");
}
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务
1.7.3 可缓存线程池(CachedThreadPool)
- 特点:无核心线程,非核心线程数量无限,执行完闲置 60s 后回收,任务队列为不存储元素的阻塞队列。
- 应用场景:执行大量、耗时少的任务。
使用示例:
// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
System.out.println("执行任务啦");
}
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);
1.7.4 单线程化线程池(SingleThreadExecutor)
- 特点:只有 1 个核心线程,无非核心线程,执行完立即回收,任务队列为链表结构的有界队列。
- 应用场景:不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作,如数据库操作、文件操作等。
使用示例:
// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
System.out.println("执行任务啦");
}
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);
1.8 对比
1.9 总结
Executors 的 4 个功能线程池虽然方便,但现在已经不建议使用了,而是建议直接通过使用 ThreadPoolExecutor 的方式,这样的处理方式让写的同学更加明确线程池的运行规则,规避资源耗尽的风险。
其实 Executors 的 4 个功能线程有如下弊端:
1.FixedThreadPool 和 SingleThreadExecutor:主要问题是堆积的请求处理队列均采用 LinkedBlockingQueue,可能会耗费非常大的内存,甚至 OOM。
2.CachedThreadPool 和 ScheduledThreadPool:主要问题是线程数最大数是 Integer.MAX_VALUE,可能会创建数量非常多的线程,甚至 OOM。
原文链接:https://blog.csdn.net/u013541140/article/details/95225769
2.ThreadPoolExecutors方式创建线程池
2.1 线程池核心参数
corePoolSzie: 线程核心池所能容纳的线程数,满后仍有任务进入则进入阻塞队列等待
maximumPoolSize: 线程池最多所能容纳的线程数,阻塞队列也满后,仍有任务进入,会新建线程(非核心线程)来执行任务,核心池线程数+新建线程数不得超过此参数数值,否则会触发拒绝策略拒绝任务。即新建的非核心线程数最大值 = maximumPoolSize - corePoolSize
keepAliveTime: 非核心线程若超过此参数指定时间没有任务执行,则销毁线程
TimeUnit unit: 上个参数的时间单位,TimeUnit是枚举类型,有七种参数:
NANOSECONDS : 1微毫秒 = 1秒 / 1000 * 1000 * 1000
MICROSECONDS : 1微秒 = 1秒 / 1000 * 1000
MILLISECONDS : 1毫秒 = 1秒 /1000
SECONDS : 秒
MINUTES : 分
HOURS : 小时
DAYS : 天BlockingQueue<Runnable> workQueue: 阻塞队列,常用workQueue类型:
SynchronousQueue:这个队列接收到任务的时候,会直接提交给线程处理,而不保留它,如果所有线程都在工作怎么办?那就新建一个线程来处理这个任务!所以为了保证不出现<线程数达到了maximumPoolSize而不能新建线程>的错误,使用这个类型队列的时候,maximumPoolSize一般指定成Integer.MAX_VALUE,即无限大LinkedBlockingQueue:这个队列接收到任务的时候,如果当前线程数小于核心线程数,则新建线程(核心线程)处理任务;如果当前线程数等于核心线程数,则进入队列等待。由于这个队列没有最大值限制,即所有超过核心线程数的任务都将被添加到队列中,这也就导致了maximumPoolSize的设定失效,因为总线程数永远不会超过corePoolSize
ArrayBlockingQueue:可以限定队列的长度,接收到任务的时候,如果没有达到corePoolSize的值,则新建线程(核心线程)执行任务,如果达到了,则入队等候,如果队列已满,则新建线程(非核心线程)执行任务,又如果总线程数到了maximumPoolSize,并且队列也满了,则发生错误
DelayQueue:队列内元素必须实现Delayed接口,这就意味着你传进去的任务必须先实现Delayed接口。这个队列接收到任务时,首先先入队,只有达到了指定的延时时间,才会执行任务
threadFactory:用于创建工作线程的工厂。
handler:拒绝策略,往线程池添加任务时,将在下面两种情况触发拒绝策略:1)线程池运行状态不是 RUNNING;2)线程池已经达到最大线程数,并且阻塞队列已满时
2.1 创建线程池示例
//创建核心线程池; 核心池容量=3; 最大线程数=10; 阻塞队列类型为ArrayBlockingQueue,容量=5; KeepAliveTime = 10ms
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10, 10L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));
2.3 使用线程池
2.3.1 线程服务接口
这里写一些线程接口用来测试线程和拒绝策略
package com.huachun.service;
public interface ThreadPoolService {
void threadPool(String str);
}
2.3.2 线程池使用示例
package com.huachun.service.impl;
import com.huachun.service.ThreadPoolService;
import org.springframework.stereotype.Service;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@Service
public class ThreadPoolExecutorService implements ThreadPoolService {
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10, 10L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));
@Override
public void threadPool(String str) {
// executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
executor.execute(() -> {
System.out.println("ThreadPoolExecutor run:" + str);
});
}
}
2.4 设置拒绝策略
2.4.1 创建线程实现类
package com.huachun.service.impl;
public class MyThread implements Runnable {
//region 变量
private int flag;
private int currentBlockingQueueSize;
/**
* @param flag 线程编号
* @param currentBlockingQueueSize 当前阻塞队列等待的线程数量
*/
public MyThread(int flag, int currentBlockingQueueSize) {
this.flag = flag;
this.currentBlockingQueueSize = currentBlockingQueueSize;
}
@Override
public void run() {
System.out.println("线程编号:" + getFlag() + "运行中----" + "当前队列中有" + currentBlockingQueueSize + "个线程");
}
//获取当前线程编号
private int getFlag() {
return flag;
}
}
2.4.2 封装拒绝策略
package com.huachun.service.impl;
import java.util.concurrent.ThreadPoolExecutor;
public class RefusePolicy {
//region 变量
private static ThreadPoolExecutor executor;
//region 构造器
public RefusePolicy(ThreadPoolExecutor executor) {
this.executor = executor;
}
public RefusePolicy() {
}
//region 四种策略设置
// AbortPolicy拒绝策略 --丢任务并抛出异常
public void SetAbortPolicy() {
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
System.out.println("正在使用AbortPolicy拒绝策略:");
}
// DiscardPolicy拒绝策略 --丢任务但不抛出异常
public void SetDiscardPolicy() {
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
System.out.println("正在使用DiscardPolicy拒绝策略:");
}
// DiscardOldestPolicy拒绝策略 --丢弃最早进入队列的任务
public void SetDiscardOldestPolicy() {
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
System.out.println("正在使用DiscardOldestPolicy拒绝策略:");
}
// CallerRunsPolicy拒绝策略 --主线程运行
public void SetCallerRunsPolicy() {
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
System.out.println("正在使用CallerRunsPolicy拒绝策略:");
}
}
2.4.3 AbortPolicy策略
package com.huachun.service.impl;
import com.huachun.service.ThreadPoolService;
import org.springframework.stereotype.Service;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
@Service
public class AbortPolicyService implements ThreadPoolService {
//加入线程池的线程数
int THREAD_COUNT = 30;
//创建核心线程池; 核心池容量=3; 最大线程数=10; 阻塞队列类型为ArrayBlockingQueue,容量=5; KeepAliveTime = 10ms
ThreadPoolExecutor executor = new ThreadPoolExecutor(3, 10, 10L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(5));
@Override
public void threadPool(String str) {
//设置策略
//调用RefusePolicy类设置拒绝策略
RefusePolicy refusePolicy = new RefusePolicy(executor);
refusePolicy.SetAbortPolicy();
try {
//将线程加入线程池
for (int i = 0; i < THREAD_COUNT; i++) {
executor.execute(new MyThread(i, executor.getQueue().size()));
}
} catch (Exception exception) {
System.out.println(exception);
} finally {
//关闭线程
executor.shutdown();
System.out.println("关闭");
}
}
}
线程池最大可容纳maximumPoolSize + WorkQueue,即15个任务,我们设置了30个向线程池加入,因为任务执行可能较快,任务数设置太少不太好容易得出结果
一开始线程池无任务,0,1,2号顺利进入核心池,核心池大小为3,3号线程进入时发现核心池满,于是3-7号线程依次进入阻塞队列,队列容量为5。然后8号任务进入时,会创建新的线程处理任务,于是8-14共7个任务会被新建的非核心线程处理,15号以后的任务进入,发现正在运行的线程数已达到maximumPoolSize,触发拒绝策略,丢弃并抛出异常,紧接着队列中的3-7也被处理。
AbortPolicy是默认策略,抛弃多余任务,并抛出异常。
2.4.4 DiscardPolicy
与默认策略类似,只是不会抛出异常,默默丢弃任务
2.4.5 DiscardOldestPolicy
前面的都是一样,0-2号3个线程仍正常进入核心池,然后3-7进入阻塞队列,8-14号新建线程去处理,但是15进入并不会被丢弃,而是丢弃队列中的最先进入的任务,即3,然后15进入队列,同理16、17、18、19进入会丢弃队列中的4、5、6、7,然后进入队列,因此3-7被抛弃,15-19会进入队列等待被处理。
2.4.6 CallerRunsPolicy
15号及以后的任务会在进入时被拒绝,然后被回退至调用者,即主线程去执行,所以,一开始15会被主线程执行,然后等待3s后,先进入的执行完毕后,其余的也会被处理
2.4.7 总结
AbortPolicy(默认):丢弃多余任务,并抛出异常
DiscardPolicy:丢弃多余任务,但不抛出异常
DiscardOldestPolicy:丢弃最先进队列的任务,然后重新尝试加入任务
CallerRunsPolicy:不会抛弃任务,也不会抛出异常,而是将任务回退至调用者执行
原文链接:https://blog.csdn.net/Rain_Butter_fly/article/details/119176734
文章评论