JAVA运行超时自动中断(强杀)的线程池

    这里包装了一下JAVA原生的线程池，提供了一个支持超时后自动中断线程的功能，当然对于某些线程是无法进行中断的（比如阻塞的线程等等），因此这个类也提供了一个可以进行设置的标志位：stopTimeOutThread。默认为false表示对于超时的线程只进行中断，如果我们设置为true之后，对于超时线程除了进行中断之外，还会调用stop方法进行强行杀死。由于stop方法的特殊性，因此使用时，需要大家根据实际的业务场景去衡量了。再每一次调用stop方法之后，我还会调用一次System.gc()这是因为，比如某个正在操作文件流的线程，突然被强行杀死后，因为这个流是没有关闭的，这会导致句柄泄漏，最直观的体现就是，我们无法删除那个文件（会体现另外一个进程正在使用），但是当下一次gc进行时，因为会调用finalize方法，这个时候就会把那个文件的句柄给释放了。

    因此，终上所述，如果在不涉及到一致性、共用锁等方面时，大部分情况下我们是可以使用stop方法强行杀死超时运行的线程的。

import java.lang.Thread.UncaughtExceptionHandler;
import java.lang.reflect.Field;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExecutorServiceHelper {
    private static final Logger LOGGER = LoggerFactory.getLogger(ExecutorServiceHelper.class);
    private String name = ExecutorServiceHelper.class.getName();
    /**
     * 默认线程池大小为可用CPU数量的两倍
     */
    public static final int DEFAULT_THREAD_COUNT = Runtime.getRuntime().availableProcessors() * 2;
    private ThreadPoolExecutor executor;
    private DelayQueue<TimeLimitFuture<?>> timeLimitJobQueue = new DelayQueue<TimeLimitFuture<?>>();
    private ExecutorService delayQueueExecutor = Executors.newSingleThreadExecutor(new ThreadFactory() {

        @Override
        public Thread newThread(Runnable r) {
            Thread thread = new Thread(r);
            thread.setName(name + "---delay thread");
            return thread;
        }
    });
    private final AtomicInteger atomicInteger = new AtomicInteger(0);
    private boolean stopTimeOutThread = false;

    public static ExecutorServiceHelper buildFixedThreadExecutor() {
        return new ExecutorServiceHelper((ThreadPoolExecutor) Executors.newFixedThreadPool(DEFAULT_THREAD_COUNT));
    }

    /**
     * 当提及的任务超出capacity的数量时，任务会被直接丢弃并向上抛出异常
     *
     * @param name 用于确定，线程池中每一个线程的名字的前缀
     * @param threadCount 最大线程数量
     * @param handler 用于接收线程抛出的异常
     * @param capacity 线程池队列中最大的任务等待数量
     * @return
     */
    public static ExecutorServiceHelper buildFixedCountThreadExecutor(String name, int threadCount, int capacity, UncaughtExceptionHandler handler) {
        return new ExecutorServiceHelper(name, new ThreadPoolExecutor(threadCount, threadCount, 0L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(capacity), new ThreadPoolExecutor.AbortPolicy()), handler);
    }

    /**
     * @param name 用于确定，线程池中每一个线程的名字的前缀
     * @param threadCount 最大线程数量
     * @param handler 用于接收线程抛出的异常
     * @return
     */
    public static ExecutorServiceHelper buildFixedThreadExecutor(String name, int threadCount, UncaughtExceptionHandler handler) {
        return new ExecutorServiceHelper(name, (ThreadPoolExecutor) Executors.newFixedThreadPool(threadCount), handler);
    }

    public static ExecutorServiceHelper buildCacheThreadExecutor() {
        return new ExecutorServiceHelper((ThreadPoolExecutor) Executors.newCachedThreadPool());
    }

    /**
     * @param name用于确定，线程池中每一个线程的名字的前缀
     * @param handler用于接收线程抛出的异常
     * @return
     */
    public static ExecutorServiceHelper buildCacheThreadExecutor(String name, UncaughtExceptionHandler handler) {
        return new ExecutorServiceHelper(name, (ThreadPoolExecutor) Executors.newCachedThreadPool(), handler);
    }

    private ExecutorServiceHelper(ThreadPoolExecutor executor) {
        init(ExecutorServiceHelper.class.getName(), executor, null);
    }

    private ExecutorServiceHelper(String name, ThreadPoolExecutor executor, UncaughtExceptionHandler handler) {
        init(name, executor, handler);
    }

    private void init(String name, ThreadPoolExecutor executor, UncaughtExceptionHandler handler) {
        this.executor = executor;
        this.name = name;
        executor.setThreadFactory(getThreadFactory(handler));
        initDelayMonitor();
    }

    private ThreadFactory getThreadFactory(UncaughtExceptionHandler handler) {
        return new ThreadFactory() {

            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName(name + "---job thread---" + atomicInteger.getAndIncrement());
                if (handler != null) {
                    thread.setUncaughtExceptionHandler(handler);
                }
                return thread;
            }
        };
    }

    private void initDelayMonitor() {
        delayQueueExecutor.execute(() -> {
            while (!Thread.interrupted()) {
                TimeLimitFuture<?> timeLimitFuture = null;
                try {
                    timeLimitFuture = timeLimitJobQueue.take();
                    Object result = timeLimitFuture.future.get(1, TimeUnit.MILLISECONDS);
                    if (timeLimitFuture.callbackWarp != null) {
                        timeLimitFuture.callbackWarp.setResult(result);
                    }
                } catch (Exception e) {
                    if (e instanceof InterruptedException || e instanceof ExecutionException || e instanceof TimeoutException) {
                        timeLimitFuture.future.cancel(true);
                        if (stopTimeOutThread) {
                            killThread((FutureTask<?>) timeLimitFuture.future);
                            LOGGER.error("future.kill");
                        } else {
                            LOGGER.error("future.cancel");
                        }
                        timeLimitFuture = null;
                    } else {
                        LOGGER.error(e.getMessage(), e);
                    }
                }
            }
        });
    }

    @SuppressWarnings("deprecation")
    private void killThread(FutureTask<?> submit) {
        try {
            // 利用反射，强行取出正在运行该任务的线程
            Field runner = submit.getClass().getDeclaredField("runner");
            runner.setAccessible(true);
            Thread execThread = (Thread) runner.get(submit);
            execThread.stop();
            execThread = null;
            // 为了防止句柄泄漏，这里催促jvm进行gc回收，那是因为进行gc回收时，可以收回被stop的线程所占用的句柄
            System.gc();
        } catch (Exception e) {
            LOGGER.error(e.getMessage(), e);
        }
    }

    public void execute(Runnable job) {
        executor.execute(job);
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public void execute(Runnable job, long limitTime, TimeUnit unit) {
        Future<?> future = executor.submit(job);
        timeLimitJobQueue.put(new TimeLimitFuture(future, null, limitTime, unit));
    }

    public <T> Future<T> submit(Callable<T> timeLimitJob) {
        return executor.submit(timeLimitJob);
    }

    /**
     * @param timeLimitJob
     * @param callBack 接收返回值的回调
     * @param millisecondLimitTime 毫秒值
     */
    public <T> void submit(Callable<T> timeLimitJob, CallBack<T> callBack, long millisecondLimitTime) {
        Future<T> future = executor.submit(timeLimitJob);
        timeLimitJobQueue.put(new TimeLimitFuture<T>(future, new CallBackWarp<T>(callBack), millisecondLimitTime, TimeUnit.MILLISECONDS));
    }

    public <T> void submit(Callable<T> timeLimitJob, CallBack<T> callBack, long limitTime, TimeUnit unit) {
        Future<T> future = executor.submit(timeLimitJob);
        timeLimitJobQueue.put(new TimeLimitFuture<T>(future, new CallBackWarp<T>(callBack), limitTime, unit));
    }

    public int getWattingCount() {
        return executor.getQueue().size();
    }

    public void removeAllWattingJob() {
        executor.getQueue().clear();
    }

    public void shutdownNow() {
        executor.shutdownNow();
    }

    public boolean isStopTimeOutThread() {
        return stopTimeOutThread;
    }

    public void setStopTimeOutThread(boolean stopTimeOutThread) {
        this.stopTimeOutThread = stopTimeOutThread;
    }

    public static interface CallBack<T> {
        void callback(T result);
    }

    private static class CallBackWarp<T> {
        private CallBack<T> callBack;

        public CallBackWarp(CallBack<T> callBack) {
            this.callBack = callBack;
        }

        @SuppressWarnings("unchecked")
        public void setResult(Object result) {
            callBack.callback((T) result);
        }

    }

    private static class TimeLimitFuture<T> implements Delayed {
        private Future<T> future;
        private long limitTime;
        private long triggerTime;
        private CallBackWarp<T> callbackWarp;

        public TimeLimitFuture(Future<T> future, CallBackWarp<T> callbackWarp, long limitTime, TimeUnit unit) {
            this.future = future;
            this.limitTime = limitTime;
            // 为了让时间更正确，这里进行一下时间转换
            this.triggerTime = TimeUnit.NANOSECONDS.convert(limitTime, unit) + System.nanoTime();
            this.callbackWarp = callbackWarp;
        }

        @Override
        public int compareTo(Delayed o) {
            if (o == null || !(o instanceof TimeLimitFuture))
                return 1;
            if (o == this)
                return 0;
            TimeLimitFuture<?> future = (TimeLimitFuture<?>) o;
            if (this.limitTime > future.limitTime) {
                return 1;
            } else if (this.limitTime == future.limitTime) {
                return 0;
            } else {
                return -1;
            }
        }

        @Override
        public long getDelay(TimeUnit unit) {
            return unit.convert(triggerTime - System.nanoTime(), TimeUnit.NANOSECONDS);
        }

    }
}