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

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

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

1. 添加依赖

            redis.clients
            jedis
            3.3.0
        

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 myzset = jedis.zrangeWithScores("myzset", 0, 1);
                // 如果读取记录为空
                if(myzset.isEmpty())
                {
                    // 延时1秒
                    try {
                        Thread.sleep(1000);

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    continue;
                }
                Iterator 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

可以看到添加业务的时间加上延迟时间就是业务到期时间，在业务到期的下一秒java + redis zset实现延迟队列（定时到期执行任务），就输出了到期提示。

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