分布式延时队列之Redis，亲测有效

分布式延时队列之使用Redis的Redisson

上代码

工具代码

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBlockingQueue;

@Slf4j
public class DelayTaskQueueExecutor<T> {
    final private RBlockingQueue<T> queue;
    final private Thread msgLooper;
    private final DelayTaskQueueExecutor.Processor<T> processor;

    public interface Processor<T> {
        void process(T task) throws InterruptedException;
    }

    public DelayTaskQueueExecutor(String threadName, RBlockingQueue<T> queue, DelayTaskQueueExecutor.Processor<T> processor) {
        this.queue = queue;
        this.processor = processor;
        this.msgLooper = new Thread(this::looper);
        this.msgLooper.setName(threadName);
        this.msgLooper.start();
    }

    private void looper() {
        while(true) {
            try {
                T task = queue.take();
                processor.process(task);
            } catch (InterruptedException e) {
                break;
            } catch (Exception e) {
                log.error(String.format("TaskQueueExecutor %s run task exception",
                        this.msgLooper.getName()), e);
            }
        }
    }
}

import io.micrometer.core.instrument.util.StringUtils;
import lombok.NonNull;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RBlockingDeque;
import org.redisson.api.RBlockingQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;

import java.util.Objects;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class RedisDelayQueueUtil {
    /**
     * 初始化延迟队列
     *
     * @param redisson
     * @param queueName
     * @param threadName
     * @param processor
     * @param <T>
     * @return
     */
    public static <T> RDelayedQueue<T> initDelayQueue(RedissonClient redisson, String queueName, String threadName, DelayTaskQueueExecutor.Processor<T> processor) {
        RBlockingQueue<T> blockingQueue = redisson.getBlockingQueue(queueName);
        RDelayedQueue<T> delayedQueue = redisson.getDelayedQueue(blockingQueue);
        new DelayTaskQueueExecutor<T>(threadName, blockingQueue, processor);
        return delayedQueue;
    }

    /**
     * 添加延迟队列
     *
     * @param value
     * @param delay
     * @param timeUnit
     * @param queueName
     * @param redissonClient
     * @param <T>
     * @return
     */
    public static <T> boolean addDelayQueue(@NonNull T value, @NonNull long delay, @NonNull TimeUnit timeUnit, @NonNull String queueName, @NonNull RedissonClient redissonClient) {
        if (StringUtils.isBlank(queueName) || Objects.isNull(value)) {
            return false;
        }
        try {
            RBlockingDeque<Object> blockingDeque = redissonClient.getBlockingDeque(queueName);
            RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
            delayedQueue.offer(value, delay, timeUnit);
            log.info("(添加延时队列成功) 队列名：{}，队列值：{}，延迟时间：{}", queueName, value, timeUnit.toSeconds(delay) + "秒");
        } catch (Exception e) {
            log.error("(添加延时队列失败) {}", e.getMessage());
            throw new RuntimeException("(添加延时队列失败)");
        }
        return true;
    }

    /**
     * 获取延迟队列
     *
     * @param queueName
     * @param redissonClient
     * @param <T>
     * @return
     * @throws InterruptedException
     */
    public static <T> T getDelayQueue(@NonNull String queueName, @NonNull RedissonClient redissonClient) {
        if (StringUtils.isBlank(queueName)) {
            return null;
        }
        RBlockingDeque<Object> blockingDeque = redissonClient.getBlockingDeque(queueName);
        RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
        T value = (T) delayedQueue.poll();
        return value;
    }

    /**
     * 删除指定队列中的消息
     *
     * @param t 指定删除的消息对象队列值(同队列需保证唯一性)
     * @param queueName 指定队列键
     * @param redissonClient
     * @param <T>
     * @return
     */
    public static <T> boolean removeDelayedQueue(@NonNull T t, @NonNull String queueName, @NonNull RedissonClient redissonClient) {
        if (StringUtils.isBlank(queueName) || Objects.isNull(t)) {
            return false;
        }
        RBlockingDeque<Object> blockingDeque = redissonClient.getBlockingDeque(queueName);
        RDelayedQueue<Object> delayedQueue = redissonClient.getDelayedQueue(blockingDeque);
        boolean flag = delayedQueue.remove(t);
        return flag;
    }

    /**
     * 重置指定队列中的消息
     *
     * @param t 指定重置的消息对象队列值(同队列需保证唯一性)
     * @param delay
     * @param timeUnit
     * @param queueName 指定队列键
     * @param redissonClient
     * @param <T>
     * @return
     */
    public static <T> boolean resetDelayedQueue(@NonNull T t, @NonNull long delay, @NonNull TimeUnit timeUnit, @NonNull String queueName, @NonNull RedissonClient redissonClient) {
        removeDelayedQueue(t, queueName, redissonClient);
        return addDelayQueue(t, delay, timeUnit, queueName, redissonClient);
    }
}

代码使用（在业务类中使用）

public ServiceImpl implements Service {
	@Autowired
    private RedissonClient redisson;
    
	@PostConstruct
    public void initDelayQueue() {
        RedisDelayQueueUtil.initDelayQueue(redisson, "queueName", "threadName", this::process);
    }
    
	// 执行的业务方法
	public void process(String param) {
		System.out.println("param : " + param);
	}
	
	// 添加任务
	public void addTask(Map paramMap) {
			// 如果只加一次使用这个方法
	        RedisDelayQueueUtil.addDelayQueue(JsonUtil.objectToJson(paramMap), 10, TimeUnit.SECONDS, "queueName", redisson);
	        // 这个方法使用场景：如果需要定期重置延时时间，如果在规定时间内没有重置延时时间在执行业务方法
	        RedisDelayQueueUtil.resetDelayedQueue(JsonUtil.objectToJson(paramMap), 10, TimeUnit.SECONDS, "queueName", redisson);
	    }
}