java - 重写 ThreadPoolExecutor afterExecute 方法 - 有什么缺点吗？

Question

钩子(Hook)方法的优点:

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

beforeExecute(Thread, Runnable) and afterExecute(Runnable, Throwable) methods that are called before and after execution of each task. These can be used to manipulate the execution environment; for example, reinitializing ThreadLocals, gathering statistics, or adding log entries

我正在使用自定义 ThreadPoolExecutor 来处理未捕获的异常。我可以在 Runnable 和 Callable 中添加 try{} catch{} block ，但假设您不能强制开发人员添加这些 block 在相关的 Runnable 和 Callable 任务中。

这个 CustomThreadPoolExecutor 覆盖了 ThreadPoolExecutor 中的 afterExecute() 方法，如下所示(我已将变量 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 秒才能完成。

通过覆盖 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);
}