延时队列实现自定义定时服务

1.延时队列元素定义

public class DelayTask  implements Delayed {

    /**
     * 开始计时时间 不设置则默认为当前系统时间
     */
    private transient Date taskStartTime = new Date();
    /**
     * 过期时间 不设置则默认1分钟
     */
    private  long taskExpiredTime; // = 60 * 1000
    private   Long tId  ;
    /**
     * 初始设置开始计时时间
     * taskStartTime 开始时间 [String] [yyyy-MM-dd HH:mm:ss]
     * taskExpiredTime 过期时间 [long] 单位：s
     * @param taskStartTime
     * @param taskExpiredTime
     */
    public void initTaskTime(String taskStartTime, long taskExpiredTime,Long tId ) {
        this.tId = tId;
        if(!StringUtils.isEmpty(taskStartTime)) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            try {
                this.taskStartTime = sdf.parse(taskStartTime);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        this.taskExpiredTime = taskExpiredTime;
        this.taskExpiredTime += this.taskStartTime.getTime();
    }

    @Override
    public long getDelay(TimeUnit unit) {
        long delay  =  unit.convert(taskExpiredTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
//        MyLog.info(this.gettId() + " get delay:"+ delay);
        return delay;
    }

    @Override
    public int compareTo(Delayed o) {
        int i =  (this.getDelay(TimeUnit.MILLISECONDS) - ((DelayTask) o).getDelay(TimeUnit.MILLISECONDS)) > 0 ? 1:-1;

        MyLog.debug(this.gettId() +"   Leader id =  :" + (i!= 1 ? this.gettId(): ((DelayTask) o).gettId() )   );
        return i ;
     }

    public Date getTaskStartTime() {
        return taskStartTime;
    }

    public void setTaskStartTime(Date taskStartTime) {
        this.taskStartTime = taskStartTime;
    }

    public long getTaskExpiredTime() {
        return taskExpiredTime;
    }

    public void setTaskExpiredTime(long taskExpiredTime) {
        this.taskExpiredTime = taskExpiredTime;
    }

    public Long gettId() {
        return tId;
    }

    public void settId(Long tId) {
        this.tId = tId;
    }
}

　　2.实现延时队列

public class DelayQueueHelper {

    private static final Logger logger = LoggerFactory.getLogger(DelayQueueHelper.class);


    private volatile static DelayQueueHelper delayQueueHelper = null;

    private DelayQueue<DelayTask> queue = new DelayQueue<DelayTask>();

    private DelayQueueHelper() {
    }

    public static DelayQueueHelper getInstance() {
        if(delayQueueHelper == null) {
            synchronized(DelayQueueHelper.class) {
                delayQueueHelper = new DelayQueueHelper();
                new Thread(()->{
                    start();
                }).start();
            }
        }
        return delayQueueHelper;
    }

    public synchronized void addTask(DelayTask task) {
        queue.offer(task);
//        queue.put(task);
    }

    public void removeTask(Long tId ) {
        if(tId == null){
            return;
        }
        for(Iterator<DelayTask> iterator = queue.iterator(); iterator.hasNext();) {
            DelayTask queueTask = (DelayTask) iterator.next();
            if(queueTask.gettId().equals(tId)){
                queue.remove(queueTask);
            }
         }
    }

    public DelayQueue<DelayTask> getQueue() {
        return queue;
    }


    public static void start(){
        DelayQueue queue  = delayQueueHelper.getQueue();
        while (true) {
            DelayTask task = null;
            try {
//                logger.info("等待定时任务");
                //queue.take() ; 阻塞 出现bug 未做优化。。。。改为poll() .非阻塞
                task = (DelayTask) queue.poll();
                if(task == null ){
                    sleep(1000);
                    continue;
                }
                 Long tId =  task.gettId();
                 SchedulerTaskHelper.start(tId);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

}

　　3.定义任务接口

public interface SchedulerTask extends Runnable {

    String getDescription();

    void setDescription(String description);

    Runnable getStopCall();

    void setStopCall(Runnable stopCall);

    Runnable getBeforeCall();

    void setBeforeCall(Runnable excuteCall);

    Runnable getAfterCall();

    void setAfterCall(Runnable afterCall);

    default Long getId() {
        return TaskIdSequnce.creatId();
    }


    Long getDelayTime();

    void setDelayTime(Long delayTime);


}

　　4.抽象任务

public abstract class AbstractSchedulerTask  implements  SchedulerTask{

    /**
     * 任务结束后的回调函数
     */
    private  Runnable stopCall = null;
    private  Runnable beforeCall = null;
    private  Runnable afterCall = null;
    /**
     * 切面延时执行时间
     */
    private Long  delayTime = 0l ;


    private String description;
    public AbstractSchedulerTask(String description ,Long  delayTime){
        this.description= description;
        this.delayTime = delayTime;
    }

    public AbstractSchedulerTask(String description ){
        this.description= description;
    }



    private Long id = TaskIdSequnce.creatId() ;

    @Override
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public void setStopCall(Runnable stopCall){
        this.stopCall = stopCall;
    }

    public Runnable getStopCall(){
        return this.stopCall;
    }

    public Runnable getBeforeCall () {
        return beforeCall;
    }

    public void setBeforeCall (Runnable beforeCall) {
        this.beforeCall = beforeCall;
    }

    public Runnable getAfterCall() {
        return afterCall;
    }

    public void setAfterCall(Runnable afterCall) {
        this.afterCall = afterCall;
    }

    public Long getDelayTime() {
        return delayTime;
    }

    public void setDelayTime(Long delayTime) {
        this.delayTime = delayTime;
    }
}

　　5.定时任务执行时间配置表

public class SchedulerTaskConf {
    /**
     * 计划id
     */
    private Long id;
    /**
     * 任务列表
     */
    private SchedulerTaskConf[] confs;
    /**
     * 时间周期， 单位ms
     * 0 表示只执行一次
     */
    private Long interval = 0l ;
    /**
     * 开始时间 [String] [yyyy-MM-dd HH:mm:ss]
     */
    private String taskStartTime  = DateUtil.date2String(new Date(),"yyyy-MM-dd HH:mm:ss");
    /**
     *  taskExpiredTime 过期时间 [long] 单位：ms
     */
    private Long taskExpiredTime = 10000l;
    /**
     * 截止时间 [String] [yyyy-MM-dd HH:mm:ss]
     */
    private String taskEndTime ="9999-01-01 01:01:01" ;
    /**
     * 最后一次执行时间戳
     */
    private Long lastExcTime = 0l;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public SchedulerTaskConf[] getConfs() {
        return confs;
    }

    public void setConfs(SchedulerTaskConf[] confs) {
        this.confs = confs;
    }

    public Long getInterval() {
        return interval;
    }

    public void setInterval(Long interval) {
        this.interval = interval;
    }

    public String getTaskStartTime() {
        return taskStartTime;
    }

    public void setTaskStartTime(String taskStartTime) {
        this.taskStartTime = taskStartTime;
    }

    public Long getTaskExpiredTime() {
        return taskExpiredTime;
    }

    public void setTaskExpiredTime(Long taskExpiredTime) {
        this.taskExpiredTime = taskExpiredTime;
    }

    public String getTaskEndTime() {
        return taskEndTime;
    }

    public void setTaskEndTime(String taskEndTime) {
        this.taskEndTime = taskEndTime;
    }

    public Long getLastExcTime() {
        return lastExcTime;
    }

    public void setLastExcTime(Long lastExcTime) {
        this.lastExcTime = lastExcTime;
    }

    public SchedulerTaskConf (String  taskStartTime ,Long taskExpiredTime,Long interval,String taskEndTime){
        //设置开始时间，格式 : yyyy-MM-dd HH:mm:ss
        this.setTaskStartTime(taskStartTime);
        //设置延时执行时间10s
        this.setTaskExpiredTime(taskExpiredTime);
        // 设置发送频率 20s
        this.setInterval(interval);
        //设置定时任务终止时间，格式 : yyyy-MM-dd HH:mm:ss
        if(taskEndTime != null ){
            this.setTaskEndTime(taskEndTime  );
        }
    }

    public Long  getFirst(){
        Long nowStamp =  System.currentTimeMillis();
        Long start=  DateUtil.stringToTimestamp(this.getTaskStartTime(),"").getTime();
        Long end ;
        if(StringUtils.isEmpty(this.getTaskEndTime())){
              end = Long.MAX_VALUE;
        }else {
              end = DateUtil.stringToTimestamp(this.getTaskEndTime(),"").getTime();
        }
        if(start+ taskExpiredTime < nowStamp){
            return nowStamp;
        }
        if(start+ taskExpiredTime >  end){
            return 0l;
        }
        Long myStart = start+ taskExpiredTime;
        if(this.getConfs()!= null ){
            SchedulerTaskConf[] confs = this.getConfs();
            for(SchedulerTaskConf  conf:confs){
                Long nodeStart =  conf.getFirst();
                if(nodeStart <= 0l){
                    continue;
                }
                if(myStart >  nodeStart){
                    myStart = nodeStart;
                }
            }
        }
        return myStart;
    }


    public Long  getNext(){
        Long nowStamp =  System.currentTimeMillis();
        //超过定时截止日期，则直接返回0
        if(!StringUtils.isEmpty(this.getTaskEndTime())    ){
            Long end = DateUtil.stringToTimestamp(this.getTaskEndTime(),"").getTime();
            if(end  < nowStamp ){
                return  0L ;
            }
        }
        if(this.getLastExcTime()< nowStamp ){
            this.setLastExcTime(nowStamp);
        }else {
            return this.getLastExcTime() ;
        }

        if(interval <=0 ){
            return  0l ;
        }
        Long next = this.getLastExcTime() + interval;
        if(this.getConfs()!= null ){
            SchedulerTaskConf[] confs = this.getConfs();
            for(SchedulerTaskConf  conf:confs){
                Long nodeNext =  conf.getNext();
                if(nodeNext <= 0l){
                    continue;
                }
                if(next >  nodeNext){
                    next = nodeNext;
                }
            }
        }
        if(next  < this.getLastExcTime() ){
            return  0l ;
        }
        return next;
    }
}

　　6.

通过延时队列实现定时任务操作

public class SchedulerTaskHelper {

    private static final Logger logger = LoggerFactory.getLogger(SchedulerTaskHelper.class);


    private volatile static Map<Long,SchedulerTaskConf> confMap = new HashMap<Long,SchedulerTaskConf>();
    private volatile static Map<Long,SchedulerTask> taskMap = new HashMap<Long,SchedulerTask>();
    private static ThreadPool tp = new DefaultThreadPool(1);

    public static ThreadPool getThreadPool(){
        return tp;
    }
    /**
     * 任务生成并添加
     * @param schedulerTask
     * @param taskConf
     */
    public static void registryTask(SchedulerTask schedulerTask,SchedulerTaskConf taskConf){

        if(!taskMap.containsKey(schedulerTask.getId())){
            synchronized (confMap){
                if(!taskMap.containsKey(schedulerTask.getId())) {
                    taskMap.put(schedulerTask.getId(),schedulerTask);
                }
            }
        }
        if(confMap.containsKey(schedulerTask.getId())){
            logger.error("此任务已经存在定时计划");
//            System.out.println("此任务已经存在定时计划");
        }else {
            synchronized (confMap){
                if(!confMap.containsKey(schedulerTask.getId())){
                     confMap.put(schedulerTask.getId(),taskConf);
                }
            }
        }
        taskInit(schedulerTask,taskConf);
    }

    /**
     * 任务第一次添加队列
     * @param schedulerTask
     * @param taskConf
     */
    public static void taskInit(SchedulerTask schedulerTask,SchedulerTaskConf taskConf){
        DelayQueueHelper delayQueueHelper =   DelayQueueHelper.getInstance();
        DelayTask delayTask = new DelayTask();
        Long start =  taskConf.getFirst();
        if(start <= 0l){
            return;
        }
        Long now = System.currentTimeMillis();
        delayTask.initTaskTime(DateUtil.date2String(new Date(),""),start - now , schedulerTask.getId());
        delayQueueHelper.addTask(delayTask);
        logger.info("定时任务初始化成功： id = " + delayTask.gettId());
    }

    /**
     * 添加下一次执行任务到队列
     * @param schedulerTask
     * @param taskConf
     */
    public static void taskNextIn(SchedulerTask schedulerTask,SchedulerTaskConf taskConf){
        DelayQueueHelper delayQueueHelper =   DelayQueueHelper.getInstance();
        DelayTask delayTask = new DelayTask();
        Long next = taskConf.getNext();
//        MyLog.info(schedulerTask.getDescription() + "下次执行时间： " + DateUtil.stampToTime(next));
        if(next <= 0l){
            stop(schedulerTask   );
            return;
        }
        Long now = System.currentTimeMillis();

        delayTask.initTaskTime(DateUtil.date2String(new Date(),""),next - now , schedulerTask.getId());
//        if(delayTask.gettId() == 1l){
//            System.out.println("任务"+ JSONObject.toJSONString(delayTask));
//            System.out.println("1");
//        }
        MyLog.debug(schedulerTask.getDescription() + " 下次执行时间在： " + (next/1000 - now/1000 ) +"s 后");
//        MyLog.debug( "TaskStartTime: " + DateUtil.date2String(delayTask.getTaskStartTime(),"") +", TaskExpiredTime : "+  DateUtil.stampToTime(delayTask.getTaskExpiredTime()));
        delayQueueHelper.addTask(delayTask);
    }

    /**
     * 线程执行任务
     * @param  id
     */
    public static void  start(Long id ){
        SchedulerTaskConf conf = confMap.get(id);
        if(conf == null ){
            logger.error("定时任务时间配置丢失:"+ id);
        }

        SchedulerTask schedulerTask =  taskMap.get(id);
        if(schedulerTask == null ){
            logger.error("定时任务丢失:"+ schedulerTask.getDescription());
        }
        logger.info(" 执行定时任务 " +schedulerTask.getDescription() );
        taskNextIn(schedulerTask,conf);
        tp.execute(schedulerTask);
    }

    //获取任务类名
    public static String getClassName(Long id ){
        SchedulerTask task  =  taskMap.get(id);
        return task.getClass().getName();
    }

    //移除任务
    public static boolean removeTask(Long id  ){
        if(taskMap.containsKey(id)){
            taskMap.remove(id);
            return true;
        }
         return false;
     }

    public static boolean stop(SchedulerTask schedulerTask){
        if(schedulerTask.getStopCall() != null ){
            new Thread(schedulerTask.getStopCall()).start();
        }
       return removeTask(schedulerTask.getId()  );
    }

}

　　7.

任务id生成器，每次+1  唯一性

public class TaskIdSequnce {
    static Long l = 0l ;

    public static Long creatId(){
        synchronized(l){
            //自增1
            l =    l +1l ;
            return l;
        }
    }
}

　　8 .线程池接口

public interface ThreadPool<Job extends SchedulerTask> {
    void execute(Job job);
    void shutdown();
    void addWorkers(int num);
    void removeWorker(int num);
    int getJobSize();
}

　　9.实现线程池

public class DefaultThreadPool<Job extends SchedulerTask>  implements ThreadPool<Job> {
    private static final Logger logger = LoggerFactory.getLogger(DefaultThreadPool.class);

    private    int MAX_WORKER_SIZE = 10 ;

    private    int DEFAULT_WORKER_SIZE = 5;

    private    int MIN_WORKER_SIZE = 5;

    private List<Worker> workers = Collections.synchronizedList(new ArrayList<Worker>());

    private final LinkedList<Job> jobs = new LinkedList<Job>();

    private AtomicLong threadNum = new AtomicLong();

    private int workerNum = DEFAULT_WORKER_SIZE;

    public void execute(Job job) {
        if(job!=null){
            synchronized (jobs){
                jobs.add(job);
                jobs.notify();
            }
        }
    }

    public void shutdown() {
        for(Worker  worker:workers){
            worker.shutdown();
        }

    }

    public void addWorkers(int num) {
        synchronized (jobs){
            if(num + workerNum> MAX_WORKER_SIZE){
                num = MAX_WORKER_SIZE- workerNum;
            }
            initializeWorkers(num);
            workerNum += num;
        }
    }

    public void removeWorker(int num) {
        synchronized (jobs){
            if(num > workerNum){
                try {
                    throw new IllegalAccessException("");
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
            int count =0  ;
            while (count< num ){
                Worker worker = workers.get(count);
                if(workers.remove(worker)){
                    worker.shutdown();
                    count++;
                }
            }
            workerNum -= count;
        }
    }

    public int getJobSize() {
        return jobs.size();
    }

    public DefaultThreadPool( int MAX_WORKER_SIZE, int DEFAULT_WORKER_SIZE,int  MIN_WORKER_SIZE){
        this.MAX_WORKER_SIZE = MAX_WORKER_SIZE;
        this.DEFAULT_WORKER_SIZE = DEFAULT_WORKER_SIZE;
        this.MIN_WORKER_SIZE = MIN_WORKER_SIZE;
        initializeWorkers(DEFAULT_WORKER_SIZE);
    }

    public DefaultThreadPool(int num ){
        workerNum = num > MAX_WORKER_SIZE ?MAX_WORKER_SIZE:num< MIN_WORKER_SIZE?MIN_WORKER_SIZE:num ;
        initializeWorkers(workerNum);
    }

    private void initializeWorkers(int num){
        for(int i = 0 ; i < num; i ++ ){
            Worker worker = new Worker();
            workers.add(worker);
            Thread thread = new Thread(worker,"ThreadPool-Worker-"+ threadNum.incrementAndGet() );
            thread.start();

        }

    }

    class Worker implements Runnable {
        private  volatile  boolean running = true ;
        public void run() {
            while (running){
                Job job = null ;
                synchronized (jobs){
                    while(jobs.isEmpty()){
                        try {
                            jobs.wait();
                        }catch (Exception e){
                            Thread.currentThread().interrupt();
                            return;
                        }
                    }
                    job = jobs.removeFirst();
                }
                if(job != null ){
                    try {
                        Thread td =Thread.currentThread();
                        try {
                            if(job.getId() != null ){
                                td.setName("Scheduler-Worker-" + threadNum.incrementAndGet() +"-"+ SchedulerTaskHelper.getClassName(job.getId()));
                            }else {
                                td.setName("Scheduler-Worker-" + threadNum.incrementAndGet() +"-" );
                            }
                        }catch (Exception e){
                        }
                        if(job.getBeforeCall()!= null ){
                            try {
                                job.getBeforeCall().run(); ;
                            }catch (Exception e){
                                logger.error("线程池前调错误");
                            }
                        }
                        job.run();
                        if(job.getAfterCall() != null ){
                            try {
                                if(job.getDelayTime()> 0 ){
                                    Object waitO  = new Object();
                                    synchronized (waitO){
                                        waitO.wait(job.getDelayTime());
                                    }
//                                    Thread.sleep();
                                }
                                job.getAfterCall().run();
                            }catch (Exception e){
                                logger.error("线程池后调错误"+ ExceptionUtil.getMessage(e));
                            }
                        }
                    }catch (Exception e){

                    }
                }

            }
        }

        public void  shutdown(){
            running = false ;
        }
    }
}