JAVA自带延时队列DelayQueue集成

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.DelayQueue;


/**
 * 延迟队列管理器配置类
 * 用于管理和配置延迟队列相关组件
 */
@Configuration
public class DelayQueueManager {
    /**
     * 声明一个静态的延迟队列，用于存储DelayedTask任务
     * 使用静态初始化块初始化延迟队列，确保其在类加载时就被初始化
     */
    private static final DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();

    /**
     * 创建并返回一个静态的延迟队列实例
     * 该方法确保在整个应用中只有一个延迟队列实例，避免重复创建
     * @return 延迟队列实例
     */
    @Bean
    public static DelayQueue<DelayedTask> getDelayQueue() {
        return delayQueue;
    }

    /**
     * 向延迟队列中添加任务
     * 该方法允许外部将任务添加到延迟队列中，由延迟队列负责任务的调度和执行
     * @param task 要添加到延迟队列的任务，必须实现Delayed接口
     */
    public void addTask(DelayedTask task) {
        delayQueue.put(task);
    }
}

import com.bladex.common.delay.DelayedTask;
import com.bladex.system.service.impl.DelayQueueService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//延迟队列消费者类，负责消费延迟队列中的任务
@Component
public class DelayQueueConsumer {
    private final DelayQueue<DelayedTask> delayQueue;// 延迟队列，存储DelayedTask对象
    private final DelayQueueService delayQueueService;// 延迟队列服务，处理具体的任务逻辑
    private ExecutorService executorService;// 线程池，用于执行消费任务

    /**
     * 构造函数注入DelayQueue和DelayQueueService
     *
     * @param delayQueue 延迟队列，用于任务的存储和获取
     * @param delayQueueService 延迟队列服务，用于处理任务
     */
    @Autowired
    public DelayQueueConsumer(DelayQueue<DelayedTask> delayQueue, DelayQueueService delayQueueService) {
        this.delayQueue = delayQueue;
        this.delayQueueService = delayQueueService;
    }

    //初始化方法，启动线程池并开始消费延迟队列中的任务
    @PostConstruct
    public void init() {
        executorService = Executors.newSingleThreadExecutor(); // 创建单线程执行服务
        executorService.submit(this::run); // 提交消费任务到线程池执行
    }

    /**
     * 消费延迟队列中的任务
     *
     * 循环等待任务到期并处理，如果线程被中断则退出循环
     */
    private void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                DelayedTask task = delayQueue.take(); // 阻塞直到有任务到期
                delayQueueService.handleTaskByTaskId(task.getTaskId());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();// 如果线程被中断，则设置当前线程的中断状态，并退出循环
                break;
            }
        }
    }

    //销毁方法，关闭线程池
    @PreDestroy
    public void shutdown() {
        if (executorService != null && !executorService.isShutdown()) {
            executorService.shutdownNow();// 请求关闭线程池并尝试立即停止所有活动的执行任务
        }
    }
}

在需要加入延时队列的地方，注入：

 @Resource
 private DelayQueueManager delayQueueManager;
 
 并调用方法：
 delayQueueManager.addTask(new DelayedTask(taskId, 5, TimeUnit.MINUTES));