线程池(重点)
线程池介绍
什么是线程池?
线程池就是一个可以复用线程的技术。
不使用线程池的问题:
如果用户每发起一个请求,后台就创建一个新线程来处理,下次新任务来了又要创建新线程,而创建新线程的开销是很大的,这样会严重影响系统的性能。
线程池工作原理:
例如线程池中最多可以允许创建三个工作线程, 也叫核心线程, 前面三个任务来的时候会给前面三个任务单独创建三个线程; 但是后面任务再来的时候, 因为创建的工作线程已达到最大数, 那么后面的任务就会进入任务队列中排队等待; 等前面的任务执行完成, 有空闲的线程的时候使用空闲的线程依次执行任务队列中的任务
实现线程池的方式
谁代表线程池?
JDK 5.0起提供了
代表线程池的接口:ExecutorService
如何得到线程池对象?
- 方式一:使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象
- 方式二:使用Executors(线程池的工具类)调用方法返回不同特点的线程池对象
方式一: 实现类ThreadPoolExecutor
ThreadPoolExecutor构造器的参数
ThreadPoolExecutor的构造器有如下参数
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数介绍:
- 参数一:指定线程池的线程数量(核心线程): corePoolSize ----> 不能小于0
- 参数二:指定线程池可支持的最大线程数: maximumPoolSize ----> 最大数量 >= 核心线程数量
- 参数三:指定临时线程的最大存活时间: keepAliveTime ----> 不能小于0
- 参数四:指定存活时间的单位(秒、分、时、天): unit ----> 时间单位
- 参数五:指定任务队列: workQueue ----> 不能为null
- 参数六:指定用哪个线程工厂创建线程: threadFactory ----> 不能为null
- 参数七:指定线程忙,任务满的时候,新任务拒绝策略: handler ----> 不能为null
新任务拒绝策略:
策略 | 详解 |
---|---|
ThreadPoolExecutor.AbortPolicy | 丢弃任务并抛出RejectedExecutionException异常。是默认的策略 |
ThreadPoolExecutor.DiscardPolicy | 丢弃任务,但是不抛出异常 这是不推荐的做法 |
ThreadPoolExecutor.DiscardOldestPolicy | 抛弃队列中等待最久的任务 然后把当前任务加入队列中 |
ThreadPoolExecutor.CallerRunsPolicy | 由主线程负责调用任务的run()方法从而绕过线程池直接执行 |
ThreadPoolExecutor创建线程池对象示例:
ExecutorService pools = new ThreadPoolExecutor(3,
5,
8,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(6),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
思考:
临时线程什么时候创建啊?
- 新任务提交时发现核心线程都在忙,任务队列也满了,并且还可以创建临时线程,此时才会创建临时线程。
什么时候会开始拒绝任务?
- 核心线程和临时线程都在忙,任务队列也满了,新的任务过来的时候才会开始任务拒绝。
线程池处理Runnable任务
ExecutorService的常用方法:
方法名称 | 说明 |
---|---|
execute(Runnable command) |
执行任务/命令,没有返回值,一般用来执行 Runnable 任务 |
shutdown() | 等任务执行完毕后关闭线程池(一般不会关闭线程池) |
shutdownNow() | 立刻关闭,停止正在执行的任务,并返回队列中未执行的任务(一般不会关闭线程池) |
演示代码:
创建一个Runnable任务线程类
public class MyRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "线程执行输出: " + i);
}
// 为了测试, 我们让每个线程睡眠3秒
try {
System.out.println(Thread.currentThread().getName() + "线程进入休眠");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + "线程执行完成");
} catch (Exception e) {
e.printStackTrace();
}
}
}
在主类中, 创建一个线程池对象并创建Runnable任务交给线程池处理
- 如果只有三个任务, 那么会被三个核心线程同时执行
public static void main(String[] args) {
// 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5
ExecutorService es = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2. Runnable任务交给任务线程池处理
Runnable target = new MyRunnable();
// 三个Runnable任务会被核心线程执行
es.execute(target);
es.execute(target);
es.execute(target);
}
- 打印结果如下
pool-1-thread-1线程执行输出: 0
pool-1-thread-2线程执行输出: 0
pool-1-thread-3线程执行输出: 0
pool-1-thread-2线程执行输出: 1
pool-1-thread-2线程执行输出: 2
pool-1-thread-2线程执行输出: 3
pool-1-thread-1线程执行输出: 1
pool-1-thread-2线程执行输出: 4
pool-1-thread-3线程执行输出: 1
pool-1-thread-3线程执行输出: 2
pool-1-thread-3线程执行输出: 3
pool-1-thread-1线程执行输出: 2
pool-1-thread-3线程执行输出: 4
pool-1-thread-1线程执行输出: 3
pool-1-thread-1线程执行输出: 4
pool-1-thread-2线程进入休眠
pool-1-thread-3线程进入休眠
pool-1-thread-1线程进入休眠
pool-1-thread-3线程执行完成
pool-1-thread-1线程执行完成
pool-1-thread-2线程执行完成
- 如果核心线程全部被占用, 那么后面的任务会进入任务队列中排队等待有空闲的核心线程; 由于我们设置的任务队列数是5, 所以进入任务队列的任务数量小于等于5时, 不会创建临时线程
public static void main(String[] args) {
// 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5
ExecutorService es = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2. Runnable任务交给任务线程池处理
Runnable target = new MyRunnable();
// 三个Runnable任务会被核心线程执行
es.execute(target);
es.execute(target);
es.execute(target);
// 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程
es.execute(target);
es.execute(target);
es.execute(target);
es.execute(target);
es.execute(target);
}
- 由于核心线程都在忙, 任务队列也满了, 这时候我们再继续添加任务时, 就会创建临时线程; 因为我们设置的核心线程数是3个, 最大线程数是5个, 所以临时线程最多只会创建两个
public static void main(String[] args) {
// 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5
ExecutorService es = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2. Runnable任务交给任务线程池处理
Runnable target = new MyRunnable();
// 三个Runnable任务会被核心线程执行
es.execute(target);
es.execute(target);
es.execute(target);
// 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程(我们设置的任务队列最大允许排队5个任务)
es.execute(target);
es.execute(target);
es.execute(target);
es.execute(target);
es.execute(target);
// 三个核心线程都在忙, 任务队列满, 创建临时线程
es.execute(target);
es.execute(target);
}
- 核心线程都忙, 任务队列满, 临时线程忙, 此时再继续添加任务就会触发拒绝任务策略
public static void main(String[] args) {
// 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5
ExecutorService es = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2. Runnable任务交给任务线程池处理
Runnable target = new MyRunnable();
// 三个Runnable任务会被核心线程执行
es.execute(target);
es.execute(target);
es.execute(target);
// 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程(我们设置的任务队列最大允许排队5个任务)
es.execute(target);
es.execute(target);
es.execute(target);
es.execute(target);
es.execute(target);
// 三个核心线程都在忙, 任务队列满, 创建临时线程
es.execute(target);
es.execute(target);
// 后续任务拒绝任务会被拒绝
es.execute(target);
}
线程池处理Callable任务
ExecutorService常用方法:
方法名称 | 说明 |
---|---|
submit(Callable<T> task) |
执行Callable任务,返回未来任务对象(FutureTask)获取线程结果 |
shutdown() | 等任务执行完毕后关闭线程池 |
shutdownNow() | 立刻关闭,停止正在执行的任务,并返回队列中未执行的任务 |
注意: submit方法返回的是Future对象, Future对象是FutureTask对象继承的父类
演示代码:
定义一个Callable任务类, 用于计算1到n的和返回
package com.chenyq.d4_threadpool2;
import java.util.concurrent.Callable;
public class MyCallable implements Callable<String> {
private int n;
public MyCallable(int n) {
this.n = n;
}
@Override
public String call() throws Exception {
int sum = 0;
for (int i = 1; i <= n ; i++) {
sum += i;
}
// 为了测试, 让每一个线程任务睡眠3秒
System.out.println(Thread.currentThread().getName() + "线程进入睡眠");
Thread.sleep(3000);
System.out.println(Thread.currentThread().getName() + "线程执行完成");
return Thread.currentThread().getName() + "执行1-" + n + "结果是: " + sum;
}
}
线程池处理Callable任务时的细节和处理Callable的一样, 这里不再一一赘述, 代码如下
public static void main(String[] args) {
// 1. 创建一个线程池对象 核心线程为5, 最大线程数5, 临时线程存活6秒, 任务队列最大为5
ExecutorService pool = new ThreadPoolExecutor(3, 5, 6,
TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 2. 创建Callable任务, 调用submit方法, 交给任务线程池处理, 返回未来线程对象
// 三个Runnable任务会被核心线程执行
Future<String> f1 = pool.submit(new MyCallable(10));
Future<String> f2 = pool.submit(new MyCallable(20));
Future<String> f3 = pool.submit(new MyCallable(30));
// 三个核心线程被占满, 会进入任务队列排队等待有空闲的核心线程(我们设置的任务队列最大允许排队5个任务)
Future<String> f4 = pool.submit(new MyCallable(30));
Future<String> f5 = pool.submit(new MyCallable(40));
Future<String> f6 = pool.submit(new MyCallable(50));
Future<String> f7 = pool.submit(new MyCallable(40));
Future<String> f8 = pool.submit(new MyCallable(50));
// 三个核心线程都在忙, 任务队列满, 创建临时线程
Future<String> f9 = pool.submit(new MyCallable(80));
Future<String> f10 = pool.submit(new MyCallable(60));
// 后续任务拒绝任务会被拒绝
Future<String> f11 = pool.submit(new MyCallable(30));
// 3. 互获取未来线程的返回结果
try { // 正常的结果
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
System.out.println(f4.get());
System.out.println(f5.get());
System.out.println(f6.get());
System.out.println(f7.get());
System.out.println(f8.get());
System.out.println(f9.get());
System.out.println(f10.get());
System.out.println(f11.get());
} catch (Exception e) { // 异常的结果
e.printStackTrace();
}
}
方式二: Executors工具类创建线程池
Executors得到线程池对象的常用方法如下(工具类的方法基本都是静态方法):
Executors:线程池的工具类通过调用方法返回不同类型的线程池对象。
方法名称 | 说明 |
---|---|
ExecutorService newCachedThreadPool() | 线程数量随着任务增加而增加,如果线程任务执行完毕且空闲了一段时间则会被回收掉。 |
ExecutorService newFixedThreadPool(int nThreads) |
创建固定线程数量的线程池,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程替代它(保证线程存活数量)。 |
ExecutorService newSingleThreadExecutor () | 创建只有一个线程的线程池对象,如果该线程出现异常而结束,那么线程池会补充一个新线程。 |
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) | 创建一个线程池,可以实现在给定的延迟后运行任务,或者定期执行任务。 |
注意:Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。
例如下面代码当我们通过newFixedThreadPool方法创建线程池对象时
ExecutorService pool = Executors.newFixedThreadPool(3);
它的源码是创建了一个核心线程3, 最大线程3, 意味着没有临时线程, 所以临时线程存活时间也为0, 源码如下
public static ExecutorService newFixedThreadPool(int nThreads) { return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
演示代码:
我们演示使用
newFixedThreadPool(int nThreads)
方法创建线程池.在主类中创建Runnable任务提交到线程池
public static void main(String[] args) {
// 1. 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(3);
// 2. 提交Runnable任务到线程池
pool.execute(new MyRunnable());
pool.execute(new MyRunnable());
pool.execute(new MyRunnable());
// 提交第四个任务就已经没有多余线程了, 会被拒绝
pool.execute(new MyRunnable());
}
Executors执行Callable任务
public static void main(String[] args) throws Exception {
// 1. 创建线程池对象
ExecutorService pool = Executors.newFixedThreadPool(3);
// 2. 提交Callable任务
Future f1 = pool.submit(new MyCallable(10));
Future f2 = pool.submit(new MyCallable(20));
Future f3 = pool.submit(new MyCallable(30));
// 获取任务返回结果
System.out.println(f1.get());
System.out.println(f2.get());
System.out.println(f3.get());
}
Executors使用可能存在的陷阱
大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
方法名称 | 存在问题 |
---|---|
ExecutorService newFixedThreadPool(int nThreads) | 允许创建的线程是固定的, 但是线程允许请求的任务队列长度是无穷大的(Integer.MAX_VALUE),可能出现OOM内存溢出错误(java.lang.OutOfMemoryError ) |
ExecutorService newSingleThreadExecutor() | 允许创建的线程是固定的, 允许请求的任务队列长度是无穷大的(Integer.MAX_VALUE),可能出现OOM内存溢出错误(java.lang.OutOfMemoryError ) |
ExecutorService newCachedThreadPool() | 创建的线程数量最大上限是无穷大(Integer.MAX_VALUE), 线程数可能会随着任务1:1增长,也可能出现OOM内存溢出错误 ( java.lang.OutOfMemoryError ) |
ScheduledExecutorService newScheduledThreadPool(int corePoolSize) | 创建的线程数量最大上限是无穷大(Integer.MAX_VALUE), 线程数可能会随着任务1:1增长,也可能出现OOM内存溢出错误 ( java.lang.OutOfMemoryError ) |
阿里巴巴开发手册中明确说明, 不允许Executors创建线程池文章来源:https://www.toymoban.com/news/detail-415572.html
文章来源地址https://www.toymoban.com/news/detail-415572.html
到了这里,关于Java多线程 - 创建线程池的方法 - ThreadPoolExecutor和Executors的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!