TaskUtil多线程与定时任务

package com.taoban.util;

/**

 * 执行单次任务或定时任务工具类（用于减少new Thread()和new Timer()的使用）

 */

public class TaskUtil {

    private static Log log = LogFactory.getLog(TaskUtil.class);

    private static ExecutorService cachedExecutor = null;

    private static ScheduledExecutorService scheduledExecutor = null;

    private static Map<Runnable, Future<?>> keepRunningTasks = null;

    private static Map<Future<?>, Callback> callbackdTasks = null;

    static {

        cachedExecutor = Executors.newCachedThreadPool(new TaskUtilThreadFactory("cached"));

        scheduledExecutor = Executors.newScheduledThreadPool(5, new TaskUtilThreadFactory("scheduled"));

        Runtime.getRuntime().addShutdownHook(new Thread() {//线程池自动退出

            @Override

            public void run() {

                cachedExecutor.shutdown();

                scheduledExecutor.shutdown();

                log.info("TaskUtil executors shutdown.");

            }

        });

    }

    /**

     * 立即执行任务

     */

    public static Future<?> submit(Runnable task) {

        return cachedExecutor.submit(task);

    }

    /**

     * 自动保持任务持续运行，每分钟监视一次

     */

    public static Future<?> submitKeepRunning(Runnable task){

        Future<?> future = submit(task);

        checkInitCachedTasks();

        synchronized (keepRunningTasks) {

            keepRunningTasks.put(task, future);

        }

        return future;

    }

    /**

     * 延迟执行任务，例如延迟5秒：schedule(task,5,TimeUnit.SECONDS)

     */

    public static void schedule(Runnable task, long delay, TimeUnit unit) {

        scheduledExecutor.schedule(task, delay, unit);

    }

    /**

     * 定时执行任务一次，比如下午两点：scheduleAt(task, DateUtils.setHours(new Date(), 13))

     */

    public static void scheduleAt(Runnable task, Date time) {

        long mills = time.getTime() - System.currentTimeMillis();

        scheduledExecutor.schedule(task, mills>0 ? mills : 3, TimeUnit.MILLISECONDS);

    }

    /**

     * 定时重复执行任务，比如延迟5秒，每10分钟执行一次：scheduleAtFixRate(task, 5, TimeUnit.MINUTES.toSeconds(10), TimeUnit.SECONDS)

     */

    public static void scheduleAtFixtRate(Runnable task, long initialDelay, long delay, TimeUnit unit) {

        scheduledExecutor.scheduleWithFixedDelay(task, initialDelay, delay, unit);

    }

    /**

     * 定时重复执行任务，比如下午两点开始，每小时执行一次：scheduleAtFixRate(task, DateUtils.setHours(new Date(), 13), 1, TimeUnit.HOURS)

     */

    public static void scheduleAtFixtRate(Runnable task, Date time, long delay, TimeUnit unit) {

        long mills = time.getTime() - System.currentTimeMillis();

        scheduledExecutor.scheduleWithFixedDelay(task, mills>0 ? mills : 3, unit.toMillis(delay), TimeUnit.MILLISECONDS);

    }

    /**

     * 提交带返回值的任务，支持后续处理（调用者手动处理）

     */

    public static <T> Future<T> submit(Callable<T> task) {

        return cachedExecutor.submit(task);

    }

    /**

     * 提交带返回值的任务，支持后续处理（自动调用Callback接口）

     */

    public static <T> Future<T> submit(Callable<T> task, Callback callback) {

        Future<T> future = submit(task);

        checkInitCachedTasks();

        if(callback != null) {

            synchronized (callbackdTasks) {

                callbackdTasks.put(future, callback);

            }

        }

        return future;

    }

    /**

     * 提交任务，等待返回值（阻塞调用者）

     */

    public static <T> T wait(Callable<T> task) {

        Future<T> future = cachedExecutor.submit(task);

        try {

            return future.get();

        } catch (Exception e) {

            log.warn(e);

            return null;

        }

    }

    private static void checkInitCachedTasks() {

        if(keepRunningTasks != null) return;

        

        keepRunningTasks = new HashMap<Runnable, Future<?>>();

        callbackdTasks = new HashMap<Future<?>, Callback>();

        scheduleAtFixtRate(new CachedTasksMonitor(), 1, 1, TimeUnit.MINUTES);

    }

    /**

     * 监视需要保持运行的任务

     */

    static class CachedTasksMonitor implements Runnable {

        @Override

        public void run() {

            if(keepRunningTasks.size() > 0) {

                synchronized (keepRunningTasks) {

                    Map<Runnable, Future<?>> tempTasks = null;

                    for(Runnable task : keepRunningTasks.keySet()) {

                        Future<?> future = keepRunningTasks.get(task);

                        if(future.isDone()) {

                            future = submit(task);//恢复运行异常结束任务

                            if(tempTasks == null) tempTasks = new HashMap<Runnable, Future<?>>();

                            tempTasks.put(task, future);

                        }

                    }

                    if(tempTasks != null && tempTasks.size() > 0) keepRunningTasks.putAll(tempTasks);

                }

            }

            

            if(callbackdTasks.size() > 0) {

                synchronized (callbackdTasks) {

                    List<Future<?>> callbackedFutures = null;

                    for(Future<?> future : callbackdTasks.keySet()) {

                        final Callback callback = callbackdTasks.get(future);

                        if(future.isDone()) {

                            try{

                                final Object result = future.get(5, TimeUnit.SECONDS);

                                submit(new Runnable() {

                                    @Override

                                    public void run() {//callback可能耗时所以作为独立运行任务，而本监视器需尽快完成工作

                                        callback.handle(result);

                                    }

                                });

                                if(callbackedFutures == null) callbackedFutures = new LinkedList<Future<?>>();

                                callbackedFutures.add(future);

                            }catch (Exception e) {

                                log.warn("TaskUtil callbackedTasks warn: ", e);

                            }

                        }

                    }

                    

                    if(callbackedFutures != null && callbackedFutures.size() > 0) {

                        for(Future<?> future : callbackedFutures) {

                            callbackdTasks.remove(future);

                        }

                    }

                }

            }

        }

    }

    

    /**

     * 自定义线程名称Task-idx-name-idx2

     */

    static class TaskUtilThreadFactory implements ThreadFactory {

        private final static AtomicInteger taskutilThreadNumber = new AtomicInteger(1);

        private final AtomicInteger threadNumber = new AtomicInteger(1);

        private final String threadNamePrefix;

        TaskUtilThreadFactory(String threadNamePrefix){

            this.threadNamePrefix = threadNamePrefix;

        }

        @Override

        public Thread newThread(Runnable r) {

            Thread t = new Thread(r, String.format("TaskUtil-%d-%s-%d", taskutilThreadNumber.getAndIncrement(), this.threadNamePrefix, threadNumber.getAndIncrement()));

            t.setDaemon(false);

            t.setPriority(Thread.NORM_PRIORITY);

            return t;

        }

    }

    

    /**

     * 等待结果回调接口

     */

    public static interface Callback {

        void handle(Object result);

    }

}

来自为知笔记(Wiz)