覆盖ThreadPoolExecutor afterExecute方法 - 任何缺点？

Question

钩子方法的优点:

beforeExecute(Thread, Runnable) 和 afterExecute(Runnable, Throwable)

beforeExecute(Thread, Runnable)和afterExecute(Runnable, Throwable)在执行每个任务之前和之后调用的方法.这些可以用来操纵执行环境; 例如,重新初始化ThreadLocals,收集统计信息或添加日志条目

我使用Custom ThreadPoolExecutor来处理未捕获的异常.我可以添加try{} catch{}在块Runnable和Callable,但假设这样一个场景,你不能强迫开发者在相关添加这些模块Runnable和可赎回的任务.

这个CustomThreadPoolExecutor,覆盖afterExecute()方法ThreadPoolExecutor如下(我已经将变量b值赋给零来模拟算术异常.

import java.util.concurrent.*;
import java.util.*;

class CustomThreadPoolExecutor extends ThreadPoolExecutor {

   public CustomThreadPoolExecutor() { 
       super(1,10,60,TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(1000));
   }

   protected void afterExecute(Runnable r, Throwable t) {
     super.afterExecute(r, t);
     if (t == null && r instanceof Future<?>) {
       try {
         Object result = ((Future<?>) r).get();
         System.out.println(result);
       } catch (CancellationException ce) {
           t = ce;
       } catch (ExecutionException ee) {
           t = ee.getCause();
       } catch (InterruptedException ie) {
           Thread.currentThread().interrupt(); // ignore/reset
       }
     }
     if (t != null)
       t.printStackTrace();
   }
 }


public class CustomThreadPoolExecutorDemo{

    public static void main(String args[]){
        System.out.println("creating service");
        //ExecutorService service = Executors.newFixedThreadPool(10);
        CustomThreadPoolExecutor service = new CustomThreadPoolExecutor();
        service.submit(new Runnable(){
                 public void run(){
                    int a=4, b = 0;
                    System.out.println("a and b="+a+":"+b);
                    System.out.println("a/b:"+(a/b));
                    System.out.println("Thread Name in Runnable after divide by zero:"+Thread.currentThread().getName());
                 }
            });
        service.shutdown();
    }
}

由于submit()在框架中隐藏异常,我有重写afterExecute()方法来捕获异常.

在这个方法中,我使用下面的语句添加了阻塞调用

 Object result = ((Future<?>) r).get();

目前我有10个线程,队列容量为1000.假设我Runnable需要5秒才能完成.

通过overriding afterExecute()方法,我是否会产生任何性能开销或这种方法的任何缺点？

Answer 1

不，您的阻塞调用不会带来开销，因为任务已经完成其执行并且status >= NORMAL如您所见void runWorker(Worker w)

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);
}