java 线程池锁死 java线程池卡死

如果线程池的拒绝策略设置成DiscardPolicy或者DiscardOldestPolicy，通过Future获取执行结果，可能导致线程会一直阻塞。

问题复现

// 创建一个单线程，拒绝策略时 DiscardPolicy
private final static ThreadPoolExecutor executorService = new
ThreadPoolExecutor(1, 1, 1L, TimeUnit.MINUTES,
new SynchronousQueue(), new ThreadPoolExecutor.DiscardPolicy());
public static void main(String[] args) throws Exception {
//提交任务，阻塞 5 秒
Future taskOne = executorService.submit(() -> {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//此时，队列和线程已经都被占用，当前提交的任务会执行拒绝策略
Future taskTwo = null;
try {
taskTwo = executorService.submit(() -> System.out.println("start runable three"));
} catch (Exception e) {
System.out.println(e.getLocalizedMessage());
}
System.out.println("获取结果：");
System.out.println("task one " + taskOne.get()); //(5)等待任务one执行完毕
System.out
.println("task two " + (taskTwo == null ? null : taskTwo.get())); // (7)等待任务three执行完毕
executorService.shutdown(); //关闭线程池，阻塞直到所有任务执行完毕
}

执行结果如下，第一个task正常可以获取结果，但是第二个task一直获取不到结果，程序一直卡在这里，不会继续执行。

获取结果：

task one null

问题分析

提交任务到线程池时，会包装成 FutureTask ，初始状态是 NEW。执行的任务是包装后的FutureTask对象。

public Future> submit(Runnable task) {
if (task == null) throw new NullPointerException();
// 包装成 FutureTask
RunnableFuture ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
protected RunnableFuture newTaskFor(Runnable runnable, T value) {
return new FutureTask(runnable, value);
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}

提交执行任务方法逻辑如下。

public void execute(Runnable command) {
...
//如果线程个数小于核心线程数则新增处理线程
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
// 如果当前线程个数已经达到核心线程数则把任务放入队列
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 尝试新增处理线程
else if (! addWorker(command, false))
reject(command); //新增失败则调用拒绝策略
}

示例代码中第二个任务会执行到reject逻辑。DiscardPolicy的方法是空实现，所以新创建的FutureTask还是NEW状态，这个状态和get方法阻塞有密切的关系。

DiscardPolicy 和 DiscardOldestPolicy 代码如下。他们有一个共同点就是没有处理task的状态。
public static class DiscardPolicy implements RejectedExecutionHandler {
/**
* 空方法，task会保留在NEW状态
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}
}
public static class DiscardOldestPolicy implements RejectedExecutionHandler {
/**
* poll 出一个任务，但是没有任务处理，所以poll出来的任务是NEW状态
*/
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
e.getQueue().poll();
e.execute(r);
}
}
}

先看下 FutureTask 的状态。前面我们看到了初始化状态是NEW，其他状态说明如下。

private static final int NEW = 0; 新的任务，初始状态
private static final int COMPLETING = 1; 当任务被设置结果时，处于COMPLETING状态，这是一个中间状态。
private static final int NORMAL = 2; 表示任务正常结束。
private static final int EXCEPTIONAL = 3; 表示任务因异常而结束
private static final int CANCELLED = 4; 任务还未执行之前就调用了cancel(true)方法，任务处于CANCELLED
private static final int INTERRUPTING = 5; 当任务调用cancel(true)中断程序时，任务处于INTERRUPTING状态，这是一个中间状态。
private static final int INTERRUPTED = 6; 任务调用cancel(true)中断程序时会调用interrupt()方法中断线程运行，任务状态由INTERRUPTING转变为INTERRUPTED

继续看下 FutureTask 的get方法。

public V get() throws InterruptedException, ExecutionException {
int s = state;
//当状态值<=COMPLETING时需要等待，否则调用report返回
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
private V report(int s) throws ExecutionException {
Object x = outcome;
// 正常结束，返回结果
if (s == NORMAL)
return (V)x;
// 如果是 >= CANCELLED 抛出取消异常，包括：CANCELLED，INTERRUPTING，INTERRUPTED状态
if (s >= CANCELLED)
throw new CancellationException();
// 剩下的条件就是 EXCEPTIONAL 了，执行的任务抛出异常
throw new ExecutionException((Throwable)x)
}

到这里已经很清楚了。FutureTask状态>COMPLETING 才会返回。因为拒绝策略没有修改FutureTask的状态，FutureTask的状态一直是NEW，所以不会返回。

其他 RejectedExecutionHandler 为什么不会导致阻塞

我看看下默认的 AbortPolicy 的实现：

public static class AbortPolicy implements RejectedExecutionHandler {
// 回忆一下submit方法，最后会执行reject策略。
// AbortPolicy 直接抛出异常，调用方马上可以获取结果
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
throw new RejectedExecutionException("Task " + r.toString() +
" rejected from " +
e.toString());
}
}

CallerRunsPolicy 策略则是让调用线程执行提交的任务，执行任务时会更新状态，自然也不会阻塞。

public static class CallerRunsPolicy implements RejectedExecutionHandler {
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
if (!e.isShutdown()) {
r.run();
}
}
}

解决方案

使用带超时时间的get方法，这样使用DiscardPolicy拒绝策略不会一直阻塞。

如果一定要使用Discardpolicy 拒绝策略，需要自定义拒绝策略。

public void rejectedExecution(Runnable runable, ThreadPoolExecutor e) {
if (! e.isShutdown()) {
if(null ! = runable && runable instanceof FutureTask){
((FutureTask) runable).cancel(true);
}
}
}