延迟队列

public class DelayOrderWorkerA implements Runnable {
    @Override
    public void run() {
        //相关业务逻辑处理
        System.out.println(Thread.currentThread().getName() + "A业务处理");
    }
}

public class DelayOrderWorkerB implements Runnable {
    @Override
    public void run() {
        //相关业务逻辑处理
        System.out.println(Thread.currentThread().getName() + "B业务处理");
    }
}

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

public class DelayOrderTask<T extends Runnable> implements Delayed {

    private final long delay;
    private final T task;

    public DelayOrderTask(long timeout, T task) {
        this.delay = System.nanoTime() + timeout;
        this.task = task;
    }

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

    @Override
    public int compareTo(Delayed o) {
        return (int) (this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS));
    }

    public T getTask() {
        return task;
    }
}

import java.util.concurrent.DelayQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class DelayOrderQueueManager {

    private static final int DEFAULT_THREAD_NUM = 5;

    /**
     * 固定大小线程池
     */
    private static final ExecutorService executor = Executors.newFixedThreadPool(DEFAULT_THREAD_NUM);

    /**
     * 延时队列
     */
    private static final DelayQueue<DelayOrderTask<?>> delayQueue = new DelayQueue<>();

    private static final DelayOrderQueueManager instance = new DelayOrderQueueManager();

    public static DelayOrderQueueManager getInstance() {
        return instance;
    }

    private DelayOrderQueueManager() {
        // 守护线程
        Thread daemonThread = new Thread(this::execute);
        daemonThread.setName("DelayQueueMonitor");
        daemonThread.start();
    }

    private void execute() {
        while (true) {
            try {
                DelayOrderTask<?> delayOrderTask = delayQueue.take();
                Runnable task = delayOrderTask.getTask();
                if (null == task) {
                    continue;
                }
                executor.execute(task);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 添加任务
     *
     * @param task
     * @param time 延时时间
     * @param unit 时间单位
     */
    public void put(Runnable task, long time, TimeUnit unit) {
        // 获取延时时间
        long timeout = TimeUnit.NANOSECONDS.convert(time, unit);
        // 将任务封装成实现Delayed接口的消息体
        DelayOrderTask<?> delayOrder = new DelayOrderTask<>(timeout, task);
        // 将消息体放到延时队列中
        delayQueue.put(delayOrder);
    }
}