/* 自定义线程池。 * 构造参数: * 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个线程继续执行。