ThreadPoolExecutor的钩子方法

墨蓝 2022-10-15 13:53 131阅读 0赞

ThreadPoolExecutor提供了三个钩子方法，可以在任务执行前后或者终止时做一些额外的操作。

/* Extension hooks */
 
 /**
 * Method invoked prior to executing the given Runnable in the
 * given thread. This method is invoked by thread {@code t} that
 * will execute task {@code r}, and may be used to re-initialize
 * ThreadLocals, or to perform logging.
 *
 * This implementation does nothing, but may be customized in
 * subclasses. Note: To properly nest multiple overridings, subclasses
 * should generally invoke {@code super.beforeExecute} at the end of
 * this method.
 *
 * @param t the thread that will run task {@code r}
 * @param r the task that will be executed
 */
 protected void beforeExecute(Thread t, Runnable r) { }
 
 /**
 * Method invoked upon completion of execution of the given Runnable.
 * This method is invoked by the thread that executed the task. If
 * non-null, the Throwable is the uncaught {@code RuntimeException}
 * or {@code Error} that caused execution to terminate abruptly.
 *
 * This implementation does nothing, but may be customized in
 * subclasses. Note: To properly nest multiple overridings, subclasses
 * should generally invoke {@code super.afterExecute} at the
 * beginning of this method.
 *
 * Note: When actions are enclosed in tasks (such as
 * {@link FutureTask}) either explicitly or via methods such as
 * {@code submit}, these task objects catch and maintain
 * computational exceptions, and so they do not cause abrupt
 * termination, and the internal exceptions are not
 * passed to this method. If you would like to trap both kinds of
 * failures in this method, you can further probe for such cases,
 * as in this sample subclass that prints either the direct cause
 * or the underlying exception if a task has been aborted:
 *
 * <pre> {@code
 * class ExtendedExecutor extends ThreadPoolExecutor {
 * // ...
 * protected void afterExecute(Runnable r, Throwable t) {
 * super.afterExecute(r, t);
 * if (t == null && r instanceof Future<?>) {
 * try {
 * Object result = ((Future<?>) r).get();
 * } catch (CancellationException ce) {
 * t = ce;
 * } catch (ExecutionException ee) {
 * t = ee.getCause();
 * } catch (InterruptedException ie) {
 * Thread.currentThread().interrupt(); // ignore/reset
 * }
 * }
 * if (t != null)
 * System.out.println(t);
 * }
 * }}</pre>
 *
 * @param r the runnable that has completed
 * @param t the exception that caused termination, or null if
 * execution completed normally
 */
 protected void afterExecute(Runnable r, Throwable t) { }
 
 /**
 * Method invoked when the Executor has terminated. Default
 * implementation does nothing. Note: To properly nest multiple
 * overridings, subclasses should generally invoke
 * {@code super.terminated} within this method.
 */
 protected void terminated() { }

可以通过一个例子来感受一下。

public class TestThreadPoolHook {
 
 public static void main(String[] args) throws InterruptedException {
 ExecutorService pool = new ThreadPoolExecutor(2, 4, 60,TimeUnit.SECONDS,
 new LinkedBlockingQueue<>(2)){
 @Override
 protected void beforeExecute(Thread t, Runnable r) {
 System.out.println("前置钩子被执行");
 super.beforeExecute(t, r);
 }
 
 @Override
 protected void afterExecute(Runnable r, Throwable t) {
 System.out.println("后置钩子被执行");
 super.afterExecute(r, t);
 }
 };
 
 pool.execute(() -> System.out.println("线程执行任务"));
 TimeUnit.SECONDS.sleep(10);
 System.out.println("关闭线程池");
 pool.shutdown();
 }
 }

执行结果

前置钩子被执行
    线程执行任务
    后置钩子被执行
    关闭线程池
    
    Process finished with exit code 0