线程管理
线程池技术
什么是线程池
- 可以以 new Thread( () -> { 线程执行的任务 }).start(); 这种形式开启一个线程. 当 run()方法运行结束,线程对象会被 GC 释放.
- 在真实的生产环境中,可能需要很多线程来支撑整个应用,当线程数量非常多时 ,反而会耗尽 CPU 资源. 如果不对线程进行控制与管理,反而会影响程序的性能.
- 线程开销主要包括: 创建与启动线程的开销;线程销毁开销; 线程调度的开销; 线程数量受限 CPU 处理器数量.
- 线程池就是有效使用线程的一种常用方式. 线程池内部可以预先创建一定数量的工作线程,客户端代码直接将任务作为一个对象提交给线程池, 线程池将这些任务缓存在工作队列中,线程池中的工作线程不断地从队列中取出任务并执行.
线程池的工作流程
JDK对线程池的支持
Executor的UML图
关键类说明
Executor接口:
void | execute(Runnable command)
在将来的某个时间执行给定的命令。
|
ExecutorService接口
boolean | awaitTermination(long timeout, TimeUnit unit)
阻止所有任务在关闭请求完成后执行,或发生超时,或当前线程中断,以先到者为准。
|
<T> List<Future<T>> | invokeAll(Collection<? extends Callable<T>> tasks)
执行给定的任务,返回持有他们的状态和结果的所有完成的期货列表。
|
<T> List<Future<T>> | invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
执行给定的任务,返回在所有完成或超时到期时持有其状态和结果的期货列表,以先发生者为准。
|
<T> T | invokeAny(Collection<? extends Callable<T>> tasks)
执行给定的任务,返回一个成功完成的结果(即没有抛出异常),如果有的话。
|
<T> T | invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
执行给定的任务,返回一个已经成功完成的结果(即,不抛出异常),如果有的话在给定的超时之前过去。
|
boolean | isShutdown()
如果此执行者已关闭,则返回
true 。
|
boolean | isTerminated()
如果所有任务在关闭后完成,则返回
true 。
|
void | shutdown()
启动有序关闭,其中先前提交的任务将被执行,但不会接受任何新任务。
|
List<Runnable> | shutdownNow()
尝试停止所有主动执行的任务,停止等待任务的处理,并返回正在等待执行的任务列表。
|
<T> Future<T> | submit(Callable<T> task)
提交值返回任务以执行,并返回代表任务待处理结果的Future。
|
Future<?> | submit(Runnable task)
提交一个可运行的任务执行,并返回一个表示该任务的未来。
|
<T> Future<T> | submit(Runnable task, T result)
提交一个可运行的任务执行,并返回一个表示该任务的未来。
|
ScheduledExecutorService接口
<V> ScheduledFuture<V> | schedule(Callable<V> callable, long delay, TimeUnit unit)
创建并执行在给定延迟后启用的ScheduledFuture。
|
ScheduledFuture<?> | schedule(Runnable command, long delay, TimeUnit unit)
创建并执行在给定延迟后启用的单次操作。
|
ScheduledFuture<?> | scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
创建并执行在给定的初始延迟之后,随后以给定的时间段首先启用的周期性动作; 那就是执行将在
initialDelay 之后开始,然后是
initialDelay+period ,然后是
initialDelay + 2 * period ,等等。
|
ScheduledFuture<?> | scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)
创建并执行在给定的初始延迟之后首先启用的定期动作,随后在一个执行的终止和下一个执行的开始之间给定的延迟。
|
简单的实例:
1 package com.edu.threadpool;
2
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5
6 /**
7 * 线程池的基本使用
8 */
9 public class Test01 {
10 public static void main(String[] args) {
11 //创建有 5 个线程大小的线程池,(创建一个可重用不受限制的队列操作线程的固定数目的线程池。)
12 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);
13 //向线程池中提交 18 个任务,这 18 个任务存储到线程池的阻塞队列中, 线程池中这5 个线程就从阻塞队列中取任务执行
14 for (int i = 0; i < 18; i++) {
15 fixedThreadPool.execute(new Runnable() {
16 @Override
17 public void run() {
18 System.out.println(Thread.currentThread().getId() + " 编号的任务在执行任务, 开始时间:" + System.currentTimeMillis());
19 try {
20 Thread.sleep(3000); //模拟任务执行时长
21 } catch (InterruptedException e) {
22 e.printStackTrace();
23 }
24 }
25 });
26 }
27 }
28 }
package com.edu.threadpool;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 线程池的计划任务
* <ul>
* <li>static ThreadFactory defaultThreadFactory()
* 返回用于创建新线程的默认线程工厂。</li>
* <li>static ExecutorService newCachedThreadPool()
* 创建一个根据需要创建新线程的线程池,但在可用时将重新使用以前构造的线程。</li>
* <li>static ExecutorService newCachedThreadPool(ThreadFactory threadFactory)
* 创建一个根据需要创建新线程的线程池,但在可用时将重新使用以前构造的线程,并在需要时使用提供的ThreadFactory创建新线程。</li>
* <li>static ExecutorService newFixedThreadPool(int nThreads)
* 创建一个线程池,该线程池重用固定数量的从共享无界队列中运行的线程。</li>
* <li>static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)
* 创建一个线程池,重用固定数量的线程,从共享无界队列中运行,使用提供的ThreadFactory在需要时创建新线程。</li>
* <li>static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
* 创建一个线程池,可以调度命令在给定的延迟之后运行,或定期执行。</li>
* <li>static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory)
* 创建一个线程池,可以调度命令在给定的延迟之后运行,或定期执行。 </li>
* </ul>
*/
public class Test02 {
public static void main(String[] args) {
//创建一个有调度功能的线程池(创建一个线程池,它可安排命令给定延迟后运行或定期执行。)
ScheduledExecutorService scheduledExecutorService =
Executors.newScheduledThreadPool(10);
//在延迟 2 秒后执行任务, schedule( Runnable 任务, 延迟时长, 时间单位)
// scheduledExecutorService.schedule(new Runnable() {
// @Override
// public void run() {
// System.out.println(Thread.currentThread().getId() + " -- " +
// System.currentTimeMillis());
// }
//
// }, 2, TimeUnit.SECONDS);
//以固定的频率执行任务,开启任务的时间是固定的, 在 3 秒后执行任务,以后每隔 5 秒重新执行一次
// scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
// @Override
// public void run() {
// System.out.println(Thread.currentThread().getId() + "----在固定频率开启任务---" + System.currentTimeMillis());
// try {
// TimeUnit.SECONDS.sleep(1); //睡眠模拟任务执行时间 ,如果任务执行时长超过了时间间隔, 则任务完成后立即开启下个任务
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// }
// }, 3, 2, TimeUnit.SECONDS);
//在上次任务结束后,在固定延迟后再次执行该任务,不管执行任务耗时多长,总是在任务结束后的 2 秒再次开启新的任务
scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getId() + "----在固定频率开启任务-- - " + System.currentTimeMillis());
try {
TimeUnit.SECONDS.sleep(1); //睡眠模拟任务执行时间 ,如果任务执行时长超过了时间间隔, 则任务完成后立即开启下个任务
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}, 0, 2, TimeUnit.SECONDS);
//关闭线程池
// scheduledExecutorService.shutdown();
}
}
Executors的底层实现(只看线程池相关的)
| |
| |
|
总结:
Excutors 工 具 类 中 返 回 线 程 池 的 方 法 底 层 都 使 用 了ThreadPoolExecutor 线程池,这些方法都是 ThreadPoolExecutor 线程池的封装
分析ThreadPoolExecutor
构造器源码
public ThreadPoolExecutor(
int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
参数名 | 含义 |
corePoolSize | 指定线程池中核心线程的数量 |
maxinumPoolSize | 指定线程池中最大线程数量 |
keepAliveTime | 当线程池线程的数量超过 corePoolSize 时,多余的空 闲线程的存活时长,即空闲线程在多长时长内销毁 |
unit | 是 keepAliveTime 时长单位 |
workQueue | 任务队列,把任务提交到该任务队列中等待执行 |
threadFactory | 线程工厂,用于创建线程 |
handler | 拒绝策略,当任务太多来不及处理时,如何拒绝 |
workQueue任务队列说明
workQueue 工 作 队 列 是 指 提 交 未 执 行 的 任 务 队 列 , 它 是BlockingQueue 接口的对象,仅用于存储 Runnable 任务.根据队列功能分类,在 ThreadPoolExecutor 构造方法中可以使用以下几种阻塞
队列:
直接提交队列 | 由 SynchronousQueue 对象提供,该队列没有 容量,提交给线程池的任务不会被真实的保存,总是将新的任务提交给线程执行,如果没有空闲线程,则尝试创建新的线程,如果线程 数量已经达到 maxinumPoolSize 规定的最大值则执行拒绝策略 |
有界任务队列 | 由 ArrayBlockingQueue 实 现 , 在 创 建ArrayBlockingQueue 对象时,可以指定一个容量. 当有任务需要执 行时,如果线程池中线程数小于 corePoolSize 核心线程数则创建新 的线程;如果大于 corePoolSize 核心线程数则加入等待队列.如果队 列已满则无法加入,在线程数小于 maxinumPoolSize 指定的最大线 程 数 前 提 下 会 创 建 新 的 线 程 来 执 行 , 如 果 线 程 数 大 于maxinumPoolSize 最大线程数则执行拒绝策略 |
无界任务队列 | 由 LinkedBlockingQueue 对象实现,与有界队 列相比,除非系统资源耗尽,否则无界队列不存在任务入队失败的 情况. 当有新的任务时,在系统线程数小于 corePoolSize 核心线程 数则创建新的线程来执行任务;当线程池中线程数量大于corePoolSize 核心线程数则把任务加入阻塞队列 |
优先任务队列 | 通过 PriorityBlockingQueue 实现的,是带有 任 务 优 先 级 的 队 列 , 是 一 个 特 殊 的 无 界 队 列 . 不 管 是ArrayBlockingQueue 队列还是 LinkedBlockingQueue 队列都是按照 先进先出算法处理任务的.在 PriorityBlockingQueue 队列中可以根 据任务优先级顺序先后执行. |
有界任务队列执行任务逻辑说明
拒绝策略(handle)
ThreadPoolExecutor 构造方法的最后一个参数指定了拒绝策略.当提交给线程池的任务量超过实际承载能力时,如何处理? 即线程池中的线程已经用完了,等待队列也满了,无法为新提交的任务服务,可以通过拒绝策略来处理这个问题. JDK 提供了四种拒绝策略:
- AbortPolicy 策略,会抛出异常CallerRunsPolicy 策略,只要线程池没关闭,会在调用者线程中运行当前被丢弃的任务[Executors 工具类提供的静态方法返回的线程池默认的拒绝策略是AbortPolicy 抛出异常]
- DiscardOldestPolicy 将任务队列中最老的任务丢弃,尝试再次提交新任务
- DiscardPolicy 直接丢弃这个无法处理的任务
- RejectedExecutionHandler 如果内置的拒绝策略无法满足实际需求,可以扩展 RejectedExecutionHandler 接口
RejectedExecutionHandler接口的简单实例
1 package com.edu.threadpool;
2
3 import java.util.Random;
4 import java.util.concurrent.*;
5
6 /**
7 * 自定义拒绝策略
8 */
9 public class Test03 {
10 public static void main(String[] args) {
11 //定义任务
12 Runnable r = new Runnable() {
13 @Override
14 public void run() {
15 int num = new Random().nextInt(5);
16 System.out.println(Thread.currentThread().getId() + "--" +
17 System.currentTimeMillis() + "开始睡眠" + num + "秒");
18 try {
19 TimeUnit.SECONDS.sleep(num);
20 } catch (InterruptedException e) {
21 e.printStackTrace();
22 }
23 }
24 };
25 //创建线程池, 自定义拒绝策略
26 ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 5, 0,
27 TimeUnit.SECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new
28 RejectedExecutionHandler() {
29 @Override
30 public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
31 //r 就是请求的任务, executor 就是当前线程池
32 System.err.println(r + " is discarding..");
33 System.exit(1);
34 }
35 });
36 //向线程池提交若干任务
37 for (int i = 0; i < 20; i++) {
38 threadPoolExecutor.submit(r);
39 }
40 }
41 }
ThreadFactory
线程池中的线程就是ThreadFactory来创建的,
ThreadFactory 是一个接口,只有一个用来创建线程的方法:Thread newThread(Runnable r);当线程池中需要创建线程时就会调用该方法
自定义ThreadFactory实例
package com.edu.threadpool;
import java.util.Random;
import java.util.concurrent.*;
/**
* 自定义线程工厂
*/
public class Test04 {
public static void main(String[] args) throws InterruptedException {
//定义任务
Runnable r = new Runnable() {
@Override
public void run() {
int num = new Random().nextInt(10);
System.out.println(Thread.currentThread().getId() + "--"
+ System.currentTimeMillis() + "开始睡眠:" + num + "秒");
try {
TimeUnit.SECONDS.sleep(num);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
//创建线程池, 使用自定义线程工厂, 采用默认的拒绝策略是抛出异常
ExecutorService executorService = new ThreadPoolExecutor(
5,
5,
0,
TimeUnit.SECONDS,
new SynchronousQueue<>(), new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
//根据参数r接收的任务,创建一个线程
Thread t = new Thread(r);
t.setDaemon(true); //设置为守护线程, 当主线程运行结束,线程池中的线程会自动退出
System.out.println("创建了线程: " + t);
return t;
}
});
//提交5个任务, 当给当前线程池提交的任务超过5个时,线程池默认抛出异常
for (int i = 0; i < 5; i++) {
executorService.submit(r);
}
//主线程睡眠
Thread.sleep(10000);
//主线程睡眠超时, 主线程结束, 线程池中的线程会自动退出
}
}
ThreadPoolExecutor 的其他一些基本参数方法(可以用来监控)
int | getActiveCount()
返回正在执行任务的线程的大概数量。
|
long | getCompletedTaskCount()
返回完成执行的任务的大致总数。
|
int | getCorePoolSize()
返回核心线程数。
|
long | getKeepAliveTime(TimeUnit unit)
返回线程保持活动时间,这是超过核心池大小的线程在终止之前可能保持空闲的时间量。
|
int | getLargestPoolSize()
返回在池中同时进行的最大线程数。
|
int | getMaximumPoolSize()
返回允许的最大线程数。
|
int | getPoolSize()
返回池中当前的线程数。
|
BlockingQueue<Runnable> | getQueue()
返回此执行程序使用的任务队列。
|
RejectedExecutionHandler | getRejectedExecutionHandler()
返回不可执行任务的当前处理程序。
|
long | getTaskCount()
返回计划执行的任务的大概总数。
|
ThreadFactory | getThreadFactory()
返回用于创建新线程的线程工厂。
|
boolean | isShutdown()
如果此执行者已关闭,则返回
true 。
|
boolean | isTerminated()
如果所有任务在关闭后完成,则返回
true 。
|
boolean | isTerminating()
如果此执行者在
shutdown() 或
shutdownNow() 之后
终止 ,但尚未完全终止,则返回true。
|
代码实例
1 package com.edu.threadpool;
2
3 import java.util.concurrent.ArrayBlockingQueue;
4 import java.util.concurrent.Executors;
5 import java.util.concurrent.ThreadPoolExecutor;
6 import java.util.concurrent.TimeUnit;
7
8 /**
9 * 监控线程池
10 */
11 public class Test05 {
12 public static void main(String[] args) throws InterruptedException {
13 //先定义任务
14 Runnable r = new Runnable() {
15 @Override
16 public void run() {
17 System.out.println(Thread.currentThread().getId() + " 编号 的线程开始执行: " + System.currentTimeMillis());
18 try {
19 Thread.sleep(10000); //线程睡眠20秒,模拟任务执行时长
20 } catch (InterruptedException e) {
21 e.printStackTrace();
22 }
23 }
24 };
25
26 //定义线程池
27 ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(2, 5, 0, TimeUnit.SECONDS, new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
28
29 //向线程池提交30个任务
30 for (int i = 0; i < 30; i++) {
31 poolExecutor.submit(r);
32 System.out.println("当前线程池核心线程数量: " + poolExecutor.getCorePoolSize()
33 +", 最大线程数:"+ poolExecutor.getMaximumPoolSize()
34 + ",当前线程池大小:" + poolExecutor.getPoolSize()
35 + ",活动线程数量:" + poolExecutor.getActiveCount()
36 + ",收到任务数量:" + poolExecutor.getTaskCount()
37 + ",完成任务数: " + poolExecutor.getCompletedTaskCount()
38 + ",等待任务数:" + poolExecutor.getQueue().size()) ;
39 TimeUnit.MILLISECONDS.sleep(500);
40 }
41
42 System.out.println("-----------------------------------------------");
43 while ( poolExecutor.getActiveCount() >= 0 ){
44 System.out.println("当前线程池核心线程数量: " + poolExecutor.getCorePoolSize() + ", 最大线程数:" + poolExecutor.getMaximumPoolSize() + ",当前线程池大小:" + poolExecutor.getPoolSize() + ",活动线程数量:" + poolExecutor.getActiveCount()+ ",收到任务数量:" + poolExecutor.getTaskCount() + ",完成任务数: " + poolExecutor.getCompletedTaskCount() + ",等待任务数:" + poolExecutor.getQueue().size()) ;
45 Thread.sleep(1000);
46 }
47 }
48
49 }
对线程池进行拓展
线程池部分源码
final void runWorker(Worker w) {
//此处省略
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
//此处省略
}
简单代码实例(看第二个)
//以匿名内部类的形式来继承
// new Object(){
// @Override
// public String toString() {
// return super.toString();
// }
// };
1 package com.edu.threadpool;
2
3
4 import java.util.concurrent.ExecutorService;
5 import java.util.concurrent.LinkedBlockingQueue;
6 import java.util.concurrent.ThreadPoolExecutor;
7 import java.util.concurrent.TimeUnit;
8
9 /**
10 * 扩展线程池
11 */
12 public class Test06 {
13 //定义任务类
14 private static class MyTask implements Runnable{
15 String name;
16
17 public MyTask(String name) {
18 this.name = name;
19 }
20
21 @Override
22 public void run() {
23 System.out.println(name + "任务正在被线程 " + Thread.currentThread().getId() + " 执行");
24 try {
25 Thread.sleep(1000); //模拟任务执行时长
26 } catch (InterruptedException e) {
27 e.printStackTrace();
28 }
29 }
30 }
31
32 public static void main(String[] args) {
33 //以匿名内部类的形式来继承
34 // new Object(){
35 // @Override
36 // public String toString() {
37 // return super.toString();
38 // }
39 // };
40 //定义扩展线程池, 可以定义线程池类继承ThreadPoolExecutor,在子类中重写beforeExecute()/afterExecute()方法
41 //也可以直接使用ThreadPoolExecutor的内部类
42 ExecutorService executorService = new ThreadPoolExecutor(5, 5, 0, TimeUnit.SECONDS, new LinkedBlockingQueue<>() ){
43 //在内部类中重写任务开始方法
44 @Override
45 protected void beforeExecute(Thread t, Runnable r) {
46 System.out.println(t.getId() + "线程准备执行任务: " + ((MyTask)r).name);
47 }
48
49 @Override
50 protected void afterExecute(Runnable r, Throwable t) {
51 System.out.println( ((MyTask)r).name + "任务执行完毕");
52 }
53
54 @Override
55 protected void terminated() {
56 System.out.println("线程池退出");
57 }
58 };
59
60 //向线程池中添加任务
61 for (int i = 0; i < 5; i++) {
62 MyTask task = new MyTask("task-" + i);
63 executorService.execute(task);
64 }
65
66 //关闭线程池
67 executorService.shutdown(); //关闭线程池仅仅是说线程池不再接收新的任务 , 线程池中已接收的任务正常执行完毕
68 }
69 }
优化线程大小
程池大小对系统性能是有一定影响的,过大或者过小都会无法发挥最优的系统性能, 线程池大小不需要非常精确,只要避免极大或者极小的情况即可, 一般来说,线程池大小需要考虑 CPU 数量,内存大小等因素.
//基本公式:线程池大小 = CPU 的数量 * 目标 CPU 的使用率*( 1 + 等待时间与计算时间的比)
线程池死锁
如果在线程池中执行的 任务 A 在执行过程中又向线程池提交了任务 B, 任务 B 添加到了线程池的等待队列中, 如果任务 A 的结束需要等待任务 B 的执行结果. 就有可能会出现这种情况: 线程池中所有的工作线程都处于等待任务处理结果,而这些任务在阻塞队列中等待
执行, 线程池中没有可以对阻塞队列中的任务进行处理的线程,这种等待会一直持续下去,从而造成死锁.
总结:因此适合给线程池提交相互独立的任务,而不是彼此依赖的任务. 对于彼此依赖的任务,可以考虑分别提交给不同的线程池来执行
线程池中的异常处理
在使用 ThreadPoolExecutor 进行 submit 提交任务时,有的任务抛出了异常,但是线程池并没有进行提示,即线程池把任务中的异常给吃掉了,
解决方案
- 把 submit 提交改为 execute 执行
- 对 ThreadPoolExecutor线程池进行扩展.对提交的任务进行包装:
代码示例:
1 package com.edu.threadpool;
2
3 import java.util.concurrent.SynchronousQueue;
4 import java.util.concurrent.ThreadPoolExecutor;
5 import java.util.concurrent.TimeUnit;
6
7 /**
8 * 演示线程池可能会吃掉程序中的异常
9 */
10 public class Test07 {
11 //定义类实现Runnable接口,用于计算两个数相除
12 private static class DivideTask implements Runnable{
13 private int x;
14 private int y;
15
16 public DivideTask(int x, int y) {
17 this.x = x;
18 this.y = y;
19 }
20
21 @Override
22 public void run() {
23 System.out.println(Thread.currentThread().getName() + "计算:" + x + " / " + y + " = " + (x/y));
24 }
25 }
26 public static void main(String[] args) {
27 //创建线程池
28 ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<>());
29
30 //向线程池中添加计算两个数相除的任务
31 for (int i = 0; i < 5; i++) {
32 poolExecutor.submit(new DivideTask(10, i));
33 // poolExecutor.execute(new DivideTask(10, i));
34 }
35 /*
36 运行程序,只有四条计算结果, 我们实际上向线程池提交了5个计算任务,分析结果发现当i==0时,提交的任务会产生算术异常,线程池把该异常给吃掉了,导致我们对该异常一无所知
37 解决方法:
38 一是把submit()提交方法改为execute();
39 二是对线程池进行扩展,对submit()方法进行包装
40 */
41 }
42 }
1 package com.edu.threadpool;
2
3 import java.util.concurrent.*;
4
5 /**
6 * 自定义线程池类,对ThreadPoolExecutor进行扩展
7 */
8 public class Test08 {
9 //自定义线程池类
10 private static class TraceThreadPollExecutor extends ThreadPoolExecutor{
11 public TraceThreadPollExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
12 super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
13 }
14 //定义方法,对执行的任务进行包装,接收两个参数,第一个参数接收要执行的任务,第二个参数是一个Exception异常
15 public Runnable wrap( Runnable task, Exception exception){
16 return new Runnable() {
17 @Override
18 public void run() {
19 try {
20 task.run();
21 }catch (Exception e ){
22 exception.printStackTrace();
23 throw e;
24 }
25 }
26 };
27 }
28
29 //重写submit方法
30 @Override
31 public Future<?> submit(Runnable task) {
32 return super.submit(wrap(task, new Exception("客户跟踪异常")));
33 }
34
35 @Override
36 public void execute(Runnable command) {
37 super.execute(wrap(command, new Exception("客户跟踪异常")));
38 }
39 }
40
41 //定义类实现Runnable接口,用于计算两个数相除
42 private static class DivideTask implements Runnable{
43 private int x;
44 private int y;
45
46 public DivideTask(int x, int y) {
47 this.x = x;
48 this.y = y;
49 }
50
51 @Override
52 public void run() {
53 System.out.println(Thread.currentThread().getName() + "计算:" + x + " / " + y + " = " + (x/y));
54 }
55 }
56 public static void main(String[] args) {
57 //创建线程池
58 // ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<>());
59 //使用自定义的线程池
60 ThreadPoolExecutor poolExecutor = new TraceThreadPollExecutor(0, Integer.MAX_VALUE, 0, TimeUnit.SECONDS, new SynchronousQueue<>());
61
62 //向线程池中添加计算两个数相除的任务
63 for (int i = 0; i < 5; i++) {
64 poolExecutor.submit(new DivideTask(10, i));
65 // poolExecutor.execute(new DivideTask(10, i));
66 }
67
68 }
69 }