java线程池拒绝策略_Java线程池拒绝策略

Java提供的策略实现

CallerRunsPolicy

public static class CallerRunsPolicy implements RejectedExecutionHandler {

public CallerRunsPolicy() { }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

if (!e.isShutdown()) {

r.run();

}

}

}

CallerRunsPolicy顾名思义就是调用者自己执行，看实现就知道，如果线程池还没有关闭，就让将要被执行的线程自己调用自己的run方法，注意这里不是启动新的线程，只是执行run方法而已。

AbortPolicy

public static class AbortPolicy implements RejectedExecutionHandler {

public AbortPolicy() { }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

throw new RejectedExecutionException(“Task ” + r.toString() +

” rejected from ” +

e.toString());

}

}

AbortPolicy实现非常简单，直接抛出一个RejectedExecutionException异常，ThreadPoolExecutor默认的策略就是这一个。

DiscardPolicy

public static class DiscardPolicy implements RejectedExecutionHandler {

public DiscardPolicy() { }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

}

}

DiscardPolicy策略就是什么也不做，就是把这一个任务(Runnable)丢弃，这是因为ThreadPoolExecutor在执行拒绝策略的时候就不会新建线程来执行Runnable，也不会加入任务队列了，所以在拒绝策略中什么都不做就是简单的丢弃掉了任务(Runnable)

DiscardOldestPolicy

public static class DiscardOldestPolicy implements RejectedExecutionHandler {

public DiscardOldestPolicy() { }

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

if (!e.isShutdown()) {

e.getQueue().poll();

e.execute(r);

}

}

}

DiscardOldestPolicy策略不是丢弃提交的任务中最老的，而是丢弃任务队列中队首的任务，然后再次提交新加入的任务。

拒绝策略与模式

从线程池的拒绝策略实现上也体现了面向对象的思想，把拒绝策略抽象在RejectedExecutionHandler接口中，ThreadPoolExecutor关联(更加具体的来说是聚合aggregation)RejectedExecutionHandler接口。

好歹我们也是学过设计模式的，在设计模式中这种模式叫做策略模式(Strategy)，虽然实现类的后缀都是Policy但事实上这确实是一个策略模式的应用。对于不同拒绝算法的封装。可以看一下下面的类图。

JDK的源码中有大量的设计模式的使用，有的是非常直接的使用，甚至是为设计模式提供了接口，比如观察着模式。更多的是一些变形的使用，JDK对于设计模式的使用已经到了出神入化，大道无形的地步了。

自定义拒绝策略

既然设计上使用的是策略模式，那么对于我们来说扩展就是相当容易的事情了，简单来一个例子测试一下扩展线程池的策略模式。

import java.math.BigDecimal;

import java.util.concurrent.Executors;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

public class RejectPolicyTest {

private static AtomicInteger discardTaskNum = new AtomicInteger(0);

private static AtomicInteger executeTaskNum = new AtomicInteger(0);

public static void main(String[] args) {

int cpu = Runtime.getRuntime().availableProcessors();

ThreadPoolExecutor pool = new ThreadPoolExecutor(cpu, cpu, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(cpu),

Executors.defaultThreadFactory(), new RejectedExecutionHandler() {

@Override

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {

System.out.println(r + “:is discarded”);

discardTaskNum.incrementAndGet();

}

});

Task task = new Task();

for(int i = 0;i<100;i++){

pool.submit(task);

try {

TimeUnit.MILLISECONDS.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

pool.shutdown();

while(!pool.isTerminated());//等待所有的任务执行完成，包括任务队列中的任务

System.out.println(“discardNum:”+discardTaskNum.get());

System.out.println(“executeNum:”+executeTaskNum.get());

}

static class Task implements Runnable {

@Override

public void run() {

System.out.println(“task:” + Thread.currentThread().getName() + “is executing!”);

BigDecimal num1 = new BigDecimal(1.23456);

BigDecimal num2 = new BigDecimal(1.23456);

for (int i = 0; i < 5000000; i++) {//在我的机子上大概运行0.5s

num1.multiply(num2);

}

executeTaskNum.incrementAndGet();

}

}

}

在上面的实例中我们简单的实现了一个匿名的RejectedExecutionHandler，打印一下那些任务被丢弃了，顺便记录了一下被丢弃任务的数量。在上面的例子中的任务是执行5百万次BigDecimal类型的乘法。

总结

Java提供的4中默认策略分别是CallerRunsPolicy如果线程池没有关闭直接当前线程执行run方法,AbortPolicy抛出异常,DiscardPolicy丢弃任务,DiscardOldestPolicy丢弃任务队列头的任务。

Java线程池拒绝策略使用的是策略模式，抽象在RejectedExecutionHandler，如果需要扩展只需要实现RejectedExecutionHandler接口就可以了。