java 多线程管理线程任务，根据优先级执行 任务超时管理 线程同步执行管理

需求

需要根据优先级执行任务，有任务不是特别重要，可以稍后执行；需要对正在执行的线程做超时监控；有的API依赖任务返回结果，线程池执行的时候任务也支持同步任务；

简单测试

创建一个使用支持优先级队列（new PriorityBlockingQueue<>() ）的线程，然后每个任务实现 java.lang.Comparable 接口
new ThreadPoolExecutor(MAX_THREAD, MAX_THREAD * 2, 0L, TimeUnit.MILLISECONDS, new PriorityBlockingQueue());

简单测试一下基本可行，但是发现使用优先级列队线程池发现使用FutureTask  会抛异常 java.lang.ClassCastException: java.util.concurrent.FutureTask cannot be cast to java.lang.Comparable 所以这个方法不能再用了

Future<?> future = executor.submit(new Task());1

设计思路

1. 定义一个任务接口，继承 Runnable, Comparable，并且获取超时时间方法、优先级方法、执行时间方法、超时中止任务方法；

2. 有一个管理线程池的类，用于执行任务

3. 有一个超时检测的类

4. 有一个基本执行类，用于每次任务执行时把任务加入监控列表，有一个同步任务类，管理执行同步任务

代码实现

任务接口

/**
 * Created by zengrenyuan on 18/6/11.
 */public interface ExecuteTask extends Runnable, Comparable {


    /**
     * @return 任务超时时间
     */
    long getTimeout();    /**
     * @return 任务的优先级
     */
    int getPriority();    /**
     * 任务超时时调用
     * 用于结束任务运行
     */
    void destroy();    /**
     * @return 任务当前的执行时间
     */
    long elapsed();


}

线程池管理

import org.slf4j.Logger;import org.slf4j.LoggerFactory;import javax.annotation.PreDestroy;import java.util.concurrent.*;/**
 * Created by zengrenyuan on 18/06/11.
 */public class ExecuteThreadManager {

    private static final Logger LOG = LoggerFactory.getLogger(ExecuteThreadManager.class);    /**
     * 线程池线程名称
     */
    public static final String SCRIPT_TASK_THREAD_POOL = "TaskThreadPool";    /**
     * 最大线程数
     */
    private final int MAX_THREAD = 10;    /**
     * 一个按优先级执行的线程池
     */
    private final ThreadPoolExecutor executor = ThreadPoolUtils.newThreadPool(MAX_THREAD, SCRIPT_TASK_THREAD_POOL, new PriorityBlockingQueue<>());    private static class LazyHolder {
        private static final ExecuteThreadManager INSTANCE = new ExecuteThreadManager();
    }    private ExecuteThreadManager() {

    }    /**
     * 单例
     */
    public static final ExecuteThreadManager getInstance() {        return LazyHolder.INSTANCE;
    }    /**
     * 把任务提交到线程池执行
     */
    public void execute(ExecuteTask task) {
        executor.execute(new BaseExecuteTask(task));
    }    /**
     * 同步执行任务，等任务执行完才会往下走
     */
    public void syncExecute(ExecuteTask task) {
        SynchronizedExecuteTask syncTask = new SynchronizedExecuteTask(task);
        executor.execute(syncTask);
        syncTask.await();
    }    @PreDestroy
    private void destroy() {        try {
            executor.shutdownNow();
        } catch (Exception e) {
            LOG.error(null, e);
        }
    }

}

线程池生成工具类

import java.util.concurrent.*;/**
 * Created by zengrenyuan on 18/06/11.
 */public class ThreadPoolUtils {

    /**
     * 生成一个线程池
     *
     * @param maxThread      线程池最大数
     * @param threadPoolName 线程池名称
     * @return
     */
    public static ThreadPoolExecutor newThreadPool(int maxThread, final String threadPoolName) {        return newThreadPool(maxThread, threadPoolName, new LinkedBlockingDeque<>());
    }    /**
     * 生成一个线程池
     *
     * @param maxThread      线程池最大数
     * @param threadPoolName 线程池名称
     * @param workQueue      队列
     * @return 线程池
     */
    public static ThreadPoolExecutor newThreadPool(int maxThread, final String threadPoolName, BlockingQueue workQueue) {        return new ThreadPoolExecutor(
                maxThread,
                maxThread,                0L,
                TimeUnit.MILLISECONDS,
                workQueue,
                getThreadFactory(threadPoolName)
        );
    }    /**
     * @param threadPoolName 线程名称
     * @return 线程生成器
     */
    public static ThreadFactory getThreadFactory(final String threadPoolName) {        return new ThreadFactory() {            private int threadNumber = 1;            @Override
            public Thread newThread(Runnable r) {                return new Thread(r, threadPoolName + "-" + threadNumber);
            }
        };
    }
}

基础任务类

import org.slf4j.Logger;import org.slf4j.LoggerFactory;/**
 * 简单包装一下
 * 在任务执行前把任务加入到运行任务监控池
 * Created by zengrenyuan on 18/06/11.
 */public class BaseExecuteTask implements ExecuteTask {

    private static final Logger LOG = LoggerFactory.getLogger(BaseExecuteTask.class);    protected ExecuteTask task;    public BaseExecuteTask(ExecuteTask task) {        this.task = task;
    }    @Override
    public long getTimeout() {        return task.getTimeout();
    }    @Override
    public void destroy() {
        task.destroy();
    }    @Override
    public int getPriority() {        return task.getPriority();
    }    @Override
    public long elapsed() {        return task.elapsed();
    }    @Override
    public int compareTo(Object o) {        return task.compareTo(o);
    }    @Override
    public void run() {        try {            //任务开始前把任务加入到正在运行的任务池
            TaskPoolListener.addTask(this);
            task.run();
        } finally {
            LOG.info("运行结束");
            TaskPoolListener.removeTask(this);            //任务运行后，把任务从正在运行的任务池中移除
        }
    }


}

同步线程工具类

import java.util.concurrent.CountDownLatch;import java.util.concurrent.TimeUnit;/**
 * 同步执行任务
 * Created by zengrenyuan on 18/06/11.
 */public class SynchronizedExecuteTask extends BaseExecuteTask {

    private static final Logger LOG = LoggerFactory.getLogger(SynchronizedExecuteTask.class);    //用于记录任务是否执行完成
    private CountDownLatch latch = new CountDownLatch(1);    public SynchronizedExecuteTask(ExecuteTask task) {        super(task);
    }    @Override
    public void run() {        try {            super.run();
        } finally {
            LOG.info("运行结束");
            latch.countDown();
        }
    }    public void await() {        //任务是否在超时时间之前执行完成
        boolean finished = false;        try {
            finished = latch.await(getTimeout(), TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            LOG.error(null, e);
        } finally {            if (!finished) {
                destroy();                throw new RuntimeException("任务执行超时");
            }
        }
    }


}

任务超时监控

import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.stereotype.Service;import javax.annotation.PostConstruct;import java.util.ArrayList;import java.util.List;/**
 * Created by zengrenyuan on 18/06/11.
 */@Servicepublic class TaskPoolListener {

    private static final Logger LOG = LoggerFactory.getLogger(TaskPoolListener.class);    private final static List<ExecuteTask> scriptTasks = new ArrayList<>();    public static final int SLEEP_INTERVAL = 10_000;    private Thread thread;    @PostConstruct
    public void init() {
        thread = new Thread(new Runnable() {            @Override
            public void run() {                while (true) {                    try {
                        doTask();
                    } catch (Exception e) {
                        LOG.info(null, e);
                    } finally {                        this.sleep(SLEEP_INTERVAL);
                    }
                }
            }            private void sleep(long interval) {                try {
                    Thread.sleep(interval);
                } catch (InterruptedException var4) {
                    LOG.info(var4.getMessage());
                }

            }
        });
        thread.setName("任务运行超时检测线程");
        thread.start();
    }    /**
     * 用于监测超时任务
     * 如果任务超时调用destroy方法
     */
    public void doTask() {
        List<ExecuteTask> scriptTasks = new ArrayList<>(this.scriptTasks);        for (ExecuteTask scriptTask : scriptTasks) {            if (scriptTask.elapsed() > scriptTask.getTimeout()) {
                scriptTask.destroy();
            }
        }
    }    public static synchronized void addTask(ExecuteTask scriptTask) {
        scriptTasks.add(scriptTask);
    }    public static synchronized void removeTask(ExecuteTask scriptTask) {
        scriptTasks.remove(scriptTask);
    }    public final int size() {        return scriptTasks.size();
    }

}

原文出处