线程池RejectedExecutionHandler从FutureTask获取原始任务对象(Runnable、Thread等)

需求

线程池拒绝策略中，需要将拒绝的任务进行特殊处理（如：任务处理状态标记为失败），故需获取到原始任务对象（称为oriWork）。
拒绝策略回调中传参Runnable r为FutureTask对象（无法将该对象强转为oriWork类型），该对象的callable字段存储了oriWork，只是该对象被Executors的内部类RunnableAdapter封装着。

思路

通过反射先获取FutureTask.callable字段，然后通过反射获取Executors$RunnableAdapter中包装的原始任务对象oriWork。

实现

package com.sqlu.learn.threadpool;

import com.alibaba.fastjson.JSON;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.junit.Test;

import java.lang.reflect.Field;
import java.util.concurrent.*;
import java.util.concurrent.locks.LockSupport;

/**
 * 
 * @author: stonelu
 * @create: 2020-08-10 17:23
 **/
public class ThreadPoolExecutorTest {

    /**
     * 【核心方法】从FutureTask获取原始的任务对象
     * @param futureTask
     */
    private <T> T getOriWork(Object futureTask) {
        boolean isFutureTask = futureTask instanceof FutureTask;
        if (!isFutureTask) {
            throw new RuntimeException("不是FutureTask 无法获取原始任务：" + JSON.toJSONString(futureTask));
        }

        try {
            // 获取 FutureTask.callable
            Field callableField = FutureTask.class.getDeclaredField("callable");
            callableField.setAccessible(true);
            Object callableObj = callableField.get(futureTask);

            // 获取 上一步callable的数据类型：Executors的内部类RunnableAdapter
            Class<?>[] classes = Executors.class.getDeclaredClasses();
            Class tarClass = null;
            for (Class<?> cls : classes) {
                if (cls.getName().equals("java.util.concurrent.Executors$RunnableAdapter")) {
                    tarClass = cls;
                    break;
                }
            }

            // 获取原始任务对象
            Field taskField = tarClass.getDeclaredField("task");
            taskField.setAccessible(true);

            return  (T)taskField.get(callableObj);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException("从FutureTask获取原始任务对象失败", e);
        }
    }

    class MyThread implements Runnable {
        private int id;

        public MyThread(int id) {this.id = id;}

        @Override
        public void run() {
            System.out.println("开始任务:" + id);
            try {
                Thread.sleep(1000 * 5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("结束任务：" + id);
        }
    }

    @Test
    public void main() {
        int coreThrCount = 1;
        int maxThrCount = 1;
        long keepAliveTime = 0;
        TimeUnit keepAliveTimeUnit = TimeUnit.NANOSECONDS;

        // 任务阻塞队列
        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(1);

        // 线程池
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat("test-%d").build();

        // 拒绝策略
        RejectedExecutionHandler rejectedExecutionHandler = new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                // 获取原始任务对象
                MyThread oriWork = getOriWork(r);
                System.out.println("拒绝任务 id：" + oriWork.id);
            }
        };

        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(coreThrCount, maxThrCount, keepAliveTime, keepAliveTimeUnit, workQueue, threadFactory, rejectedExecutionHandler);

        threadPool.submit(new MyThread(0));
        threadPool.submit(new MyThread(1));
        threadPool.submit(new MyThread(2));
        threadPool.submit(new MyThread(3));

        // 一直阻塞，否则主进程将结束
        LockSupport.park();
    }

}

返回值：

开始任务:0
拒绝任务 id：2
拒绝任务 id：3
结束任务：0
开始任务:1