对于操作系统而言,创建一个线程的代价是十分昂贵的, 需要给它分配内存、列入调度,同时在线程切换时要执行内存换页,清空 CPU 缓存,切换回来时还要重新从内存中读取信息,破坏了数据的局部性。因此在并发编程中,当线程创建过多时,会影响程序性能,甚至引起程序崩溃。
而线程池属于池化管理模式,具有以下优点:
线程池包含 3 个核心部分:
当一个新任务提交至线程池之后,线程池的处理流程如下:
当 ThreadPoolExecutor 创建新线程时,通过 CAS 来更新线程池的状态 ctl。
线程池的使用主要分为以下三个步骤:
线程池的真正实现类是 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
(必需)线程池中的核心线程数,当提交一个任务时,线程池创建一个新线程执行任务,直到当前线程数等于 corePoolSize, 即使有其他空闲线程能够执行新来的任务, 也会继续创建线程;如果当前线程数为 corePoolSize,继续提交的任务被保存到阻塞队列中,等待被执行;如果执行了线程池的 **prestartAllCoreThreads()**方法,线程池会提前创建并启动所有核心线程。workQueue
(必需)用来保存等待被执行的任务的阻塞队列。 ArrayBlockingQueue
: 基于数组结构的有界阻塞队列,按 FIFO 排序任务;LinkedBlockingQueue
: 基于链表结构的阻塞队列,按 FIFO 排序任务,吞吐量通常要高于 ArrayBlockingQueue;SynchronousQueue
: 一个不存储元素的阻塞队列,每个插入操作必须等到另一个线程调用移除操作,否则插入操作一直处于阻塞状态,吞吐量通常要高于 LinkedBlockingQueue;PriorityBlockingQueue
: 具有优先级的无界阻塞队列;maximumPoolSize
(必需)线程池中能容纳的最大线程数。如果当前阻塞队列满了,且继续提交任务,则创建新的线程执行任务,前提是当前线程数小于 maximumPoolSize;当阻塞队列是无界队列, 则 maximumPoolSize 则不起作用, 因为无法提交至核心线程池的线程会一直持续地放入 workQueue。keepAliveTime
(必需)线程闲置超时时长。如果超过该时长,非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时,核心线程也会超时回收。unit
(必需)keepAliveTime 的单位,常用的有:TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS(秒)、TimeUnit.MINUTES(分)threadFactory
(可选)创建线程的工厂,通过自定义的线程工厂可以给每个新建的线程设置一个具有识别度的线程名。默认为 DefaultThreadFactoryhandler
(可选)线程池的饱和策略,当阻塞队列满了,且没有空闲的工作线程,如果继续提交任务,必须采取一种策略处理该任务,线程池提供了 4 种策略: AbortPolicy
: 直接抛出异常,默认策略;CallerRunsPolicy
: 用调用者所在的线程来执行任务;DiscardOldestPolicy
: 丢弃阻塞队列中靠最前的任务,并执行当前任务;DiscardPolicy
: 直接丢弃任务; 也可以根据应用场景实现 RejectedExecutionHandler 接口,自定义饱和策略,如记录日志或持久化存储不能处理的任务。除了调用 ThreadPoolExecutor 自定义线程池的方式,其实 Executors 也已经为我们封装好了 4 种常见的功能线程池,如下:
// 1. 创建定长线程池对象 & 设置线程池线程数量固定为 3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task = new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);
复制代码
// 1. 创建定时线程池对象 & 设置线程池线程数量固定为 5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟 1s 后执行任务
复制代码
// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);
复制代码
// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建好 Runnable 类线程对象 & 需执行的任务
Runnable task =new Runnable(){
public void run() {
...//待执行的耗时任务
}
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);
复制代码
目前已不推荐使用功能线程池,而是通过自定义 ThreadPoolExecutor 的方式。因为直接使用功能线程池具有资源耗尽的风险。
向线程池提交任务的流程非常简单,只需要向线程池的 execute 方法传入 Runnable 对象即可。
// 向线程池提交任务
threadPool.execute(new Runnable() {
@Override
public void run() {
... //待执行的任务
}
});
本文系转载,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。
本文系转载,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。