import java.util.Date;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * @author 
 * @Time 2020/11/23 10:53
 * @description: DelayTask延時任務隊列中元素
 */


public class DelayTask implements Delayed {
    final private HotelRabbitMq data;
    final private long expire;

    /**
     * 構造延時任務
     * @param data      業(yè)務數據
     * @param expire    任務延時時間（ms）
     */
    public DelayTask(xx data, long expire) {
        super();
        this.data = data;
        this.expire = expire + System.currentTimeMillis();
    }

    public HotelRabbitMq getData() {
        return data;
    }

    public long getExpire() {
        return expire;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof DelayTask) {
            return this.data.getIdentifier().equals(((DelayTask) obj).getData().getIdentifier());
        }
        return false;
    }

    @Override
    public String toString() {
        return "{" + "data:" + data.toString() + "," + "expire:" + new Date(expire) + "}";
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.expire - System.currentTimeMillis(), unit);
    }

    @Override
    public int compareTo(Delayed o) {
        long delta = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return (int) delta;
    }
}

import com.alibaba.fastjson.JSON;
import org.fh.config.RabbitProducer;
import org.fh.entity.dyne.HotelRabbitMq;
import org.fh.entity.dyne.HotelRegister;
import org.fh.entity.util.TaskBase;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executors;

/**
 * @author 
 * @Time 2020/11/23 10:59
 * @description: DelayQueueManager延時任務管理類
 */

@Component
public class DelayQueueManager implements CommandLineRunner {

    @Autowired
    RabbitProducer rabbitProducer;

    private final Logger logger = LoggerFactory.getLogger(DelayQueueManager.class);
    private DelayQueue<DelayTask> delayQueue = new DelayQueue<>();

    /**
     * 加入到延時隊列中
     * @param task
     */
    public void put(DelayTask task) {
        logger.info("加入延時任務：{}", task);
        delayQueue.put(task);
    }

    /**
     * 取消延時任務
     * @param task
     * @return
     */
    public boolean remove(DelayTask task) {
        logger.info("取消延時任務：{}", task);
        return delayQueue.remove(task);
    }

    /**
     * 取消延時任務
     * @param taskid
     * @return
     */
    public boolean remove(String taskid) {
        return remove(new DelayTask(new HotelRabbitMq(taskid), 0));
    }

    @Override
    public void run(String... args) throws Exception {
        logger.info("初始化延時隊列");
        Executors.newSingleThreadExecutor().execute(new Thread(this::excuteThread));
    }

    /**
     * 延時任務執(zhí)行線程
     */
    private void excuteThread() {
        while (true) {
            try {
                DelayTask task = delayQueue.take();
                processTask(task);
            } catch (InterruptedException e) {
                break;
            }
        }
    }

    /**
     * 內部執(zhí)行延時任務
     * @param task
     */
    private void processTask(DelayTask task) {
        logger.info("執(zhí)行延時任務：{}", task);
        //根據task中的data自定義數據來處理相關邏輯，例 if (task.getData() instanceof XXX) {}
        //發(fā)送rabbitmq
        //rabbitProducer.sendDemoQueue(task.getData());
    }

    public void put(HotelRegister hotelRegister, int i) {
    }
}

public class DelayedTask  implements Delayed{
    
    // 任務的執(zhí)行時間
    private int executeTime = 0;
    
    public DelayedTask(int delay){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.SECOND,delay);
        this.executeTime = (int)(calendar.getTimeInMillis() /1000 );
    }
 
    /**
     * 元素在隊列中的剩余時間
     * @param unit
     * @return
     */
    @Override
    public long getDelay(TimeUnit unit) {
        Calendar calendar = Calendar.getInstance();
        return executeTime - (calendar.getTimeInMillis()/1000);
    }
 
    /**
     * 元素排序
     * @param o
     * @return
     */
    @Override
    public int compareTo(Delayed o) {
        long val = this.getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
        return val == 0 ? 0 : ( val < 0 ? -1: 1 );
    }
 
 
    public static void main(String[] args) {
        DelayQueue<DelayedTask> queue = new DelayQueue<DelayedTask>();
        
        queue.add(new DelayedTask(5));
        queue.add(new DelayedTask(10));
        queue.add(new DelayedTask(15));
 
        System.out.println(System.currentTimeMillis()/1000+" start consume ");
        while(queue.size() != 0){
            DelayedTask delayedTask = queue.poll();
            if(delayedTask !=null ){
                System.out.println(System.currentTimeMillis()/1000+" cosume task");
            }
            //每隔一秒消費一次
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }     
    }
}

 @Scheduled(cron = "0 */1 * * * ?") 每一分鐘執(zhí)行一次