Redis简单延时队列

Redis实现简单延队列, 利用zset有序的数据结构, score设置为延时的时间戳. 

实现思路:

1、使用命令 [zrangebyscore keyName socreMin socreMax] 会返回已score排序由小到大的一个list

2、list非空则使用[zrem keyName value]  删除第一个元素, 删除成功即代表消费成功, 可以解决多线程并发消费的问题.

使用jedis实现代码:

package com.nancy.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import redis.clients.jedis.Jedis;

import java.lang.reflect.Type;
import java.util.*;

/**
 * redis实现延时队列，但是对于要求行极高的环境不建议使用，主要原因：
 * 1、没有可靠的消息持久机制，消息容易丢失
 * 2、ack应答机制确实，没有传统MQ机制的可靠性
 *
 * @author  zhou.guangfeng on 2019/3/9 下午4:31
 */
public class RedisDelayQueue<T> {

    static class TaskItem<T>{
        public String id ;
        public T msg ;
    }

    private Jedis jedis ;
    private String queueKey ;
    private Type taskType = new TypeReference<TaskItem<T>>(){}.getType();

    RedisDelayQueue(Jedis jedis, String queueKey){
        this.jedis = jedis ;
        this.queueKey = queueKey ;
    }

    public void delay(T msg){
        TaskItem<T> item = new TaskItem<>() ;

        item.id = UUID.randomUUID().toString() ;
        item.msg = msg ;

        String content = JSON.toJSONString(item) ;
        try {
            Thread.sleep(10L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        jedis.zadd(queueKey, System.currentTimeMillis() + 5000, content) ;
    }

    public void loop(){
        while (!Thread.interrupted()){
            Boolean flag = consumer() ;
            try {
                if(!flag) {
                    Thread.sleep(500L);
                }
            }catch (InterruptedException ex){
                break;
            }

        }
    }

    /**
     *
     * 队列消费，利用zrem操作，删除成功即也消费。 并发环境可能出现zrem删除失败情况，从而导致无效的请求。
     * @param
     * @return
     */
    private Boolean consumer(){
         // 按照分数即时间， 有序集成员按 score 值递增(从小到大)次序排列。
         Set<String> values = jedis.zrangeByScore(queueKey, 0, System.currentTimeMillis()) ;
         if (values == null || values.isEmpty()){
            return false ;
         }

         String content = values.iterator().next() ;
         if(jedis.zrem(queueKey, content) <= 0){
             return false ;
         }

        TaskItem<T> item = JSON.parseObject(content, taskType) ;
        handleMsg(item.msg) ;
        return true ;
    }

    public void handleMsg(T msg){
        System.out.println(msg);
    }

    public static void main(String[] args) {
        RedisDelayQueue<String> queue = new RedisDelayQueue<>(AbstractDistributedLock.getJedisPool().getResource(), "delay-queue-demo") ;

        System.out.println("delay queue start, time = " + new Date());
        Thread producer = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    queue.delay("codehole:" + i);
                }
            }
        };

        Thread consumer = new Thread(){
            @Override
            public void run() {
                queue.loop();
            }
        };

        producer.start();
        consumer.start();

        try {
            producer.join();
            Thread.sleep(6000L);

            consumer.interrupt();
            consumer.join();
        }catch (InterruptedException ex){

        }finally {
            System.out.println("delay queue start, end = " + new Date());
        }

    }

}

public abstract class AbstractDistributedLock implements RedisLock {

    private static JedisPool jedisPool;

    protected static final String LOCK_SUCCESS = "OK";
    protected static final Long RELEASE_SUCCESS = 1L;
    protected static final String SET_IF_NOT_EXIST = "NX";
    protected static final String SET_WITH_EXPIRE_TIME = "EX";
    protected static final long DEFAULT_EXPIRE_TIME = 1000 * 10 ;
    protected static final long DEFAULT_DELAY_TIME = 2 ;

    static {
        JedisPoolConfig config = new JedisPoolConfig();
        // 设置最大连接数
        config.setMaxTotal(500);
        // 设置最大空闲数
        config.setMaxIdle(50);
        // 设置最大等待时间
        config.setMaxWaitMillis(1000 * 100);
        // 在borrow一个jedis实例时，是否需要验证，若为true，则所有jedis实例均是可用的
        config.setTestOnBorrow(true);
        jedisPool = new JedisPool(config, "127.0.0.1", 6379, 3000);
    }

    public static JedisPool getJedisPool() {
        return jedisPool;
    }

    @Override
    public String getLockKey(String lockKey){
        return  "lock:" + lockKey;
    }

}

运行结果:

delay queue start, time = Mon Mar 11 10:21:25 CST 2019
codehole:0
codehole:1
codehole:2
codehole:3
codehole:4
codehole:5
codehole:6
codehole:7
codehole:8
codehole:9
delay queue start, end = Mon Mar 11 10:21:31 CST 2019

以上的代码 jedis.zrangeByScore 和  jedis.zrem 为非原子操作.  如果jedis.zrem一旦失败, 会进入休眠, 造成资源浪费. 因此改造为使用lua脚本执行jedis.zrangeByScore 和  jedis.zrem 保证原子性.

   /**
     * 队列消费 使用lua脚本， 保证zrangebyscore 和 zrem操作原子性。
     *
     * @param
     * @return
     */
    private Boolean consumerWithLua(){
        String script = " local resultDelayMsg = {}; " +
                        " local arr = redis.call('zrangebyscore', KEYS[1], '0', ARGV[1]) ; " +
                        " if next(arr) == nil then return resultDelayMsg  end ;" +
                        " if redis.call('zrem', KEYS[1], arr[1]) > 0 then table.insert(resultDelayMsg, arr[1]) return resultDelayMsg end ; " +
                        " return resultDelayMsg ; ";
        Object result = jedis.eval(script, Collections.singletonList(queueKey), Collections.singletonList("" + System.currentTimeMillis()));
        List<String> msg = null ;
        if (result == null || (msg = (List<String>) result).isEmpty()) {
            return false ;
        }

        TaskItem<T> item = JSON.parseObject(msg.get(0), taskType) ;
        handleMsg(item.msg) ;
        return true ;
    }

 redis实现延时队列，但是对于要求行极高的环境不建议使用，主要原因：

1、没有可靠的消息持久机制，消息容易丢失. 需要自己实现

2、ack应答机制缺失，没有传统MQ机制的可靠性

因此, 如果对数据一致性有严格的要求, 还是建议使用传统MQ.