-
/* 自定义线程池。
-
* 构造参数:
-
* public ThreadPoolExecutor(
-
* int corePoolSize,--当前线程池核心线程数
-
* int maximumPoolSize,--当前线程池最大线程数
-
* long keepAliveTime,--保持活着的空间时间
-
* TimeUnit unit,--时间单位
-
* BlockingQueue<Runnable> workQueue,--排队等待的自定义队列
-
* ThreadFactoty threadFactory,
-
* RejectedExecutionHandler handler--队列满以后,其他任务被拒绝执行的方法
-
* ){.........}
-
/**
-
* 在使用有界队列时,若有新的任务需要执行,如果线程池实际线程数小于corePoolSize,则优先创建线程,
-
* 若大于corePoolSize,则会将任务加入队列,
-
* 若队列已满,则在总线程数不大于maximumPoolSize的前提下,创建新的线程,
-
* 若线程数大于maximumPoolSize,则执行拒绝策略。或其他自定义方式。
-
*
-
*/
ThreadExecutorPool使用有界队列
举例:
使用ArrayBlockingQueue大小为3的有界阻塞队列定义线程池,定义6个任务,分析下在线程池中的执行过程。
-
import java.util.concurrent.ArrayBlockingQueue;
-
import java.util.concurrent.ThreadPoolExecutor;
-
import java.util.concurrent.TimeUnit;
-
public class UseThreadPoolExecutor1 {
-
public static void main(String[] args) {
-
ThreadPoolExecutor pool = new ThreadPoolExecutor(
-
1, //coreSize
-
2, //MaxSize
-
60, //60
-
TimeUnit.SECONDS,
-
new ArrayBlockingQueue<Runnable>(3) //指定一种队列 (有界队列)
-
);
-
MyTask mt1 = new MyTask(1, "任务1");
-
MyTask mt2 = new MyTask(2, "任务2");
-
MyTask mt3 = new MyTask(3, "任务3");
-
MyTask mt4 = new MyTask(4, "任务4");
-
MyTask mt5 = new MyTask(5, "任务5");
-
MyTask mt6 = new MyTask(6, "任务6");
-
pool.execute(mt1);
-
pool.execute(mt2);//放入队列中,等任务1执行完后执行
-
pool.execute(mt3);//放入队列
-
pool.execute(mt4);//放入队列
-
pool.execute(mt5);//和任务1几乎同时执行,因为队列已被2、3、4占满,最大线程数为2,那么可以再创建个线程执行任务
-
pool.execute(mt6);//被拒绝异常 Task 6 rejected from java.util.concurrent.ThreadPoolExecuto
-
pool.shutdown();
-
}
-
}
分析:mt1被放入线程池后,占用corePoolSize,然后mt2和mt3跟mt4会被接着放入队列中,因为队列大小为3个已经占满。接下来的mt5算上mt1刚好等于最大线程数2,那么mt5就会新创建一个线程去执行,所以结果时mt1和mt5几乎同时被执行了。
mt6抛出被拒绝异常。
Task 6 rejected from java.util.concurrent.ThreadPoolExecutor
此时我们可以通过定义拒绝策略来执行被拒绝的逻辑:
JDK拒绝策略
AbortPolicy:默认,直接抛出异常,系统正常工作。
DiscardOldestPolicy:丢弃最老的一个请求,尝试再次提交当前任务。
举例:
-
ThreadPoolExecutor pool = new ThreadPoolExecutor(
-
1, //coreSize
-
2, //MaxSize
-
60, //60
-
TimeUnit.SECONDS,
-
new ArrayBlockingQueue<Runnable>(3) //指定一种队列 (有界队列)
-
, new DiscardOldestPolicy()
-
);
打印:
-
run taskId =1
-
run taskId =5
-
run taskId =3
-
run taskId =4
-
run taskId =6
我们发现第二个任务没有被执行,这是因为队列中放入的任务中第二个时最先被放入的,当在线程池提交第6个任务mt6时,根据DiscardOldestPolicy策略,会将最先放入的第二个任务丢弃,于是第6个任务被放入队列中。
CallerRunsPolicy:只要线程池未关闭,该策略直接在调用者线程中,运行当前被丢弃的任务。
DiscardPolicy:丢弃无法处理的任务,不给予任何处理。
自定义拒绝策略
如果需要自定义策略,可以实现RejectedExecutionHandler接口。
举例:
-
ThreadPoolExecutor pool = new ThreadPoolExecutor(
-
1, //coreSize
-
2, //MaxSize
-
60, //60
-
TimeUnit.SECONDS,
-
new ArrayBlockingQueue<Runnable>(3) //指定一种队列 (有界队列)
-
, new MyRejected()
-
);
MyRejected.java
-
package com.jeff.height.concurrent018;
-
import java.util.concurrent.RejectedExecutionHandler;
-
import java.util.concurrent.ThreadPoolExecutor;
-
public class MyRejected implements RejectedExecutionHandler{
-
public MyRejected(){
-
}
-
@Override
-
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
-
System.out.println("自定义处理..");
-
System.out.println("当前被拒绝任务为:" + r.toString());
-
}
-
}
打印:
-
run taskId =1
-
run taskId =5
-
自定义处理..
-
当前被拒绝任务为:6
-
run taskId =2
-
run taskId =3
-
run taskId =4
建议一般拒绝策略可以记录log日志,使用job异步处理。
ThreadExecutorPool使用无界队列
-
import java.util.concurrent.ArrayBlockingQueue;
-
import java.util.concurrent.BlockingQueue;
-
import java.util.concurrent.ExecutorService;
-
import java.util.concurrent.LinkedBlockingQueue;
-
import java.util.concurrent.ThreadPoolExecutor;
-
import java.util.concurrent.TimeUnit;
-
import java.util.concurrent.atomic.AtomicInteger;
-
public class UseThreadPoolExecutor2 implements Runnable{
-
private static AtomicInteger count = new AtomicInteger(0);
-
@Override
-
public void run() {
-
try {
-
int temp = count.incrementAndGet();
-
System.out.println("任务" + temp);
-
Thread.sleep(2000);
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
}
-
public static void main(String[] args) throws Exception{
-
/** 在使用无界队列时,linkedBlockingQueue。
-
* 与有界队列相比,除非系统资源耗尽,否则无界的任务队列不存在任务入队失败的情况。
-
* 当有新任务到来,系统的线程数小于corePoolSize时,则新建线程执行任务。
-
* 当达到corePoolSize后,就不会继续增加线程数量。若后续仍有新任务加入,而没有空闲的线程资源,
-
* 则任务直接进入队列等待。若任务创建和处理的速度差异很大,无界队列会保持快速增长,直到系统内存耗尽。
-
* 可以看出使用无界队列主要看corePoolSize,而最大线程数maximumPoolSize则不起作用了。
-
*/
-
BlockingQueue<Runnable> queue =
-
new LinkedBlockingQueue<Runnable>();
-
ExecutorService executor = new ThreadPoolExecutor(
-
5, //core
-
10, //max
-
120L, //2fenzhong
-
TimeUnit.SECONDS,
-
queue);
-
/**
-
* 可以发现时每次执行5个任务,就是coreSize的值,
-
* 因为其他的任务在无界队列,每次取出5个(coreSize)去执行,
-
* 线程池中的核心线程数保持不变。
-
*/
-
for(int i = 0 ; i < 20; i++){
-
executor.execute(new UseThreadPoolExecutor2());
-
}
-
Thread.sleep(1000);
-
System.out.println("queue size:" + queue.size()); //15
-
Thread.sleep(2000);
-
}
-
}
打印:
-
任务2
-
任务3
-
任务1
-
任务4
-
任务5
-
queue size:15
-
任务6
-
任务7
-
任务8
-
任务9
-
任务10
-
任务11
-
任务13
-
任务14
-
任务12
-
任务15
-
任务16
-
任务17
-
任务19
-
任务18
-
任务20
在这个例子中corePoolSize是5,使用的是linkedBlockingQueue,线程池中提交了20个线程,那么当提交前5个线程后,corePoolSize已经满了,剩下的15个只能往队列里加,当核心线程中的任务执行完成,队列中的任务就会被拿出5个来放入核心线程中执行。
我们把刚才的无界队列换成有界队列其他不变,执行:
-
BlockingQueue<Runnable> queue =
-
new ArrayBlockingQueue<Runnable>(10);
打印:
-
任务1
-
任务4
-
任务3
-
任务2
-
任务5
-
任务6
-
任务7
-
任务8
-
任务9
-
任务10
-
queue size:10
-
任务11
-
任务12
-
任务13
-
任务14
-
任务15
-
任务16
-
任务17
-
任务18
-
任务19
-
任务20
分析:corePoolSize是5,提交5个任务到核心5个线程中,然后有界队列中放入10个,打印有界队列尺寸时10,接下来还有5个线程跟corePoolSize的5个加起来等于10个,刚好等于最大线程数10个,所以线程池中有10个线程立即执行任务,然后队列中的10个线程继续执行。