Redisson实现分布式延迟队列

有一个时效性比较高的需求，类似于15分钟内未完成付款则取消订单这种。使用原生的延迟线程池或者延迟队列，会导致服务宕机时数据丢失。考虑到持久化的话，使用mysql定时扫描表也是一个方法，但是时效性低，扫描间隔低的话性能开销又大。所以决定使用redission实现分布式延迟队列，可以完美解决持久化和多节点消费的问题。直接上代码：

package com.fintek.mx.market.loan.job;

import com.balabala.base.api.commons.exception.ServiceException;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.fintek.mx.market.loan.biz.LoanApplyService;
import com.fintek.mx.market.loan.constants.CommonConstants;
import com.fintek.mx.market.loan.domain.MarketLoanAutoApplyPlan;
import com.fintek.mx.market.loan.domain.MarketLoanOrder;
import com.fintek.mx.market.loan.mapper.MarketLoanAutoApplyPlanMapper;
import com.fintek.mx.market.loan.service.ILoanOrderService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.task.AsyncTaskExecutor;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

/**
 * @Author: lv
 * @CreateDate: 2024/5/22 下午4:36
 * @Description:
 */
@Component
@Slf4j
public class AutoApplyJob {

    @Autowired
    private RedissonClient redissonClient;

    private RBlockingQueue<Long> blockingQueue;
    private RDelayedQueue<Long> delayedQueue;

    @Autowired
    @Qualifier("pushFirebaseTaskExecutor")
    private AsyncTaskExecutor pushFirebaseTaskExecutor;

    @Autowired
    private LoanApplyService loanApplyService;

    @Autowired
    private ILoanOrderService loanOrderService;

    @Autowired
    private MarketLoanAutoApplyPlanMapper marketLoanAutoApplyPlanMapper;

    @PostConstruct
    public void init() {
        // 创建一个 RBlockingQueue 实例
        blockingQueue = redissonClient.getBlockingQueue("delayedQueue");

        // 创建一个 RDelayedQueue 实例，并将其与 blockingQueue 关联
        delayedQueue = redissonClient.getDelayedQueue(blockingQueue);

        startConsumer();

    }

    // 将任务添加到延迟队列中
    public void addTaskToQueue(Long id, long delayInMinutes) {
        delayedQueue.offer(id, delayInMinutes, TimeUnit.MINUTES);
    }

    //将任务剔出队列
    public void removeTaskFromQueue(Long id) {
        boolean remove = delayedQueue.remove(id);
        if (!remove) {
            throw new ServiceException("任务不存在");
        }
    }


    public void startConsumer() {
        pushFirebaseTaskExecutor.execute(() -> {
            try {
              // 这个地方是怕关闭服务的时候 任务还在执行。嗯~~~好像也没啥鸟用
                while (!Thread.currentThread().isInterrupted()) {
                    Long id = blockingQueue.take();
                    try {
                        //这个地方其实可以异步去处理 我这里量不大 所以同步了
                        handleTask(id);
                    }catch (Exception e){
                        log.error("AutoApplyJob-----处理任务异常", e);
                    }
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                log.info("AutoApplyJob-----线程阻塞时收到关闭信号,将被正常关闭。");
            }
        });
    }

    // 处理任务的逻辑
    private void handleTask(Long id) {
        log.info("AutoApplyJob-----处理任务:{}", id);
    }

}

总结其实就是通过redission创建了一个延迟队列和一个堵塞队列，这个延迟队列与堵塞队列是绑定的，创建延迟任务时，现将任务放入延迟队列，任务到期时，会自动转入到堵塞队列。采用死循环take的方法来获取任务。redission的take方法是线程安全的，所以也不用考虑多节点消费的线程安全问题。个人理解，如果哪里不对，望谅解。