java + redis zset实现延迟队列（定时到期执行任务）_java redis zset

在Redis中，zet作为有序集合，可以利用其有序的特性，将任务添加到zset中，将任务的到期时间作为score，利用zset的默认有序特性，zrangewithscores可以获取score值最小的元素（也就是最近到期的任务），判断系统时间与该任务的到期时间大小，如果达到到期时间，就执行业务，并删除该到期任务，继续判断下一个元素，如果没有到期，就sleep一段时间（比如1秒），如果集合为空，也sleep一段时间。

1. 添加依赖

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>

2. 测试代码

package com.demo;
 
 
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Tuple;
 
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Iterator;
import java.util.Random;
import java.util.Set;
 
/**
 * 基于redis的延迟队列
 */
public class RedisDelayQueue {
 
    public static void main(String[] args) {
 
        System.out.println("begin time:" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
 
        RedisProduceThread produceThread=new RedisProduceThread();
        produceThread.start();
 
        RedisConsumeThread consumeThread=new RedisConsumeThread();
        consumeThread.start();
 
    }
 
    public static class DelayTask {
 
        /* 触发时间*/
        private long time;
        private String name;
 
        public long getTime() {
            return time;
        }
 
        public void setTime(long time) {
            this.time = time;
        }
 
        public String getName() {
            return name;
        }
 
        public void setName(String name) {
            this.name = name;
        }
    }
 
    // 添加任务线程
    public static class RedisProduceThread extends Thread {
 
        public RedisProduceThread() {
        }
 
        @Override
        public void run() {
 
            Jedis jedis = new Jedis("127.0.0.1",6379);
 
            while (true)
            {
                long timeMillis = System.currentTimeMillis();
 
                Random rnd = new Random();
                int i = rnd.nextInt(30);
 
                double delay = timeMillis / 1000 + i;
 
                jedis.zadd("myzset", delay, "item-" + i);
 
                Double doubleDelay = delay;
                long longDelay = doubleDelay.longValue();
 
                System.out.println("添加业务:item-" + i + ",添加时间：" + timeMillis / 1000 + " ,到期时间：" + longDelay + ",延迟时间:" + i + " 秒");
 
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
 
 
        }
    }
 
    // 读取到期任务线程
    public static class RedisConsumeThread extends Thread {
 
        public RedisConsumeThread() {
        }
 
        @Override
        public void run() {
 
            Jedis jedis = new Jedis("127.0.0.1",6379);
 
            while (true) {
 
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
                // 从redis读取时间最小的数据
                long timestamp = System.currentTimeMillis() / 1000;
 
                Set<Tuple> myzset = jedis.zrangeWithScores("myzset", 0, 1);
 
                // 如果读取记录为空
                if(myzset.isEmpty())
                {
                    // 延时1秒
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    continue;
                }
 
                Iterator<Tuple> iterator = myzset.iterator();
 
                while (iterator.hasNext())
                {
                    Tuple tuple = iterator.next();
                    String item = tuple.getElement();
                    Double score = tuple.getScore();
 
                    // 如果当前记录到期
                    if(timestamp >= score)
                    {
                        long lscore = score.longValue();
 
                        // 执行业务处理
                        System.out.println("到期业务:" + item + " ,到期时间：" + lscore + ",系统时间：" + timestamp);
 
                        // 处理完成后，删除当前记录
                        jedis.zrem("myzset", item);
 
                        // 继续循环读取下一条
                    }
                    else
                    {
                        // 最小记录未到期，延时1秒
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
 
                }
 
 
            }
 
        }
    }
 
}
 
 

3. 执行测试

添加业务:item-1,添加时间：1645515070 ,到期时间：1645515071,延迟时间:1 秒
到期业务:item-5 ,到期时间：1645515069,系统时间：1645515070
到期业务:item-1 ,到期时间：1645515071,系统时间：1645515071
添加业务:item-5,添加时间：1645515073 ,到期时间：1645515078,延迟时间:5 秒
到期业务:item-15 ,到期时间：1645515073,系统时间：1645515074
添加业务:item-23,添加时间：1645515076 ,到期时间：1645515099,延迟时间:23 秒
添加业务:item-11,添加时间：1645515079 ,到期时间：1645515090,延迟时间:11 秒
到期业务:item-5 ,到期时间：1645515078,系统时间：1645515079
添加业务:item-5,添加时间：1645515082 ,到期时间：1645515087,延迟时间:5 秒
添加业务:item-7,添加时间：1645515085 ,到期时间：1645515092,延迟时间:7 秒
添加业务:item-29,添加时间：1645515088 ,到期时间：1645515117,延迟时间:29 秒
到期业务:item-20 ,到期时间：1645515087,系统时间：1645515088
到期业务:item-5 ,到期时间：1645515087,系统时间：1645515088
到期业务:item-11 ,到期时间：1645515090,系统时间：1645515090

可以看到添加业务的时间加上延迟时间就是业务到期时间，在业务到期的下一秒，就输出了到期提示。

可以根据业务量的大小，每次读取的数据可以是一条数据，也可以是多条数据。一般情况下，每秒做一次检查可以满足大多数的业务需要，特殊情况下，可以将sleep的时间缩小（比如500ms或者300ms），这样可以做到更大的精确性。