Redis实现延迟任务的三种方法详解_Redis

1.前言

延迟任务（delayed task）是指在未来的某个时间点，执行相应的任务。也就是说，延迟任务是一种计划任务，它被安排在特定的时间后执行，而不是立即执行。

延迟任务的常见使用场景有以下几个：

1.定时发送通知或消息：

发送定时短信、邮件或应用内消息，如注册确认、订单状态更新、促销活动通知等。

定时推送新闻、天气预报、股票价格等实时信息。

2.异步处理和后台任务：

将耗时的操作安排为延迟任务，避免阻塞主线程或用户界面，提高系统的响应性能。

执行批量数据处理，如日志分析、数据报表生成等。

3.缓存管理和过期处理：

定时清理过期的缓存数据，释放存储空间。

更新缓存中的数据，保持数据的时效性和准确性。

4.计划任务和定时调度：

在特定时间执行系统维护任务，如数据库备份、系统更新等。

定时启动或关闭服务，以节约资源或满足业务需求。

5.订单和支付处理：

在用户下单后的一段时间内，如果用户未支付，则自动取消订单。

定时检查订单的支付状态，并更新相应的订单信息。

6.重试和失败恢复机制：

当某个操作失败时，可以在延迟一段时间后自动重试，以提高成功率。

实现分布式锁的超时释放，避免死锁情况。

7.提醒和日程管理：

设置日程提醒，如会议、生日、纪念日等。

定时提醒用户完成任务或进行某项活动。

8.定时数据采集和上报：

定期从传感器、设备或外部系统中采集数据。

定时上报应用的使用情况、统计数据或用户行为分析。

2.redis如何实现延迟任务

redis 本身并没有直接提供延迟任务的功能，但可以通过一些策略和手段，在 redis 中手动实现延迟任务。

使用 redis 实现延迟任务的主要手段有以下几个：

1. 使用过期键的事件通知执行延时任务：开启过期键通知，当 redis 中键值过期时触发时间，在事件中实现延迟代码，但因为 redis 的 key 过期时不会被及时删除，所以这个过期事件也不保证可以立即触发，所以此方式很少用来实现延迟任务（因为极其不稳定）。

2. 使用 zset 执行延时任务：在 zset 中插入延迟执行时间和任务 id，如下命令所示：

zadd delay_tasks <timestamp> <task_id>

然后，启动一个后台线程或者定时任务，定期通过 zrangebyscore 命令从有序集合中获取已到达执行时间的任务，即分数小于或等于当前时间的任务，进行执行即可实现延时任务。

3. 使用 redisson 执行延迟任务：在 redisson 框架中，提供了一个 rdelayedqueue 用于实现延迟队列，使用简单方便，推荐使用。

3.代码实现

3.1. 过期键通知事件实现

redis 提供了键空间通知功能，当某个键发生变化（过期）时，可以发送通知。你可以结合 expire 过期命令和键空间通知来实现延迟任务。

当为某个键设置过期时间时，一旦该键过期，redis 会发送一个通知。你可以订阅这个通知，并在接收到通知时执行任务。但这种方法可能不够精确，且依赖于 redis 的内部机制。

它的实现步骤是：

设置开启 redis 过期键通知事件，可以通过执行“config set notify-keyspace-events kea”命令来动态开启键空间通知功能，而无需重启 redis 服务器。

设置过期键，可以通过命令“set mykey "myvalue" ex 3”设置某个 key 3 秒后过期（3s 后执行）。

编写一个监听程序来订阅 redis 的键空间通知。这可以通过使用 redis 的发布/订阅功能来实现，具体实现代码如下（以 jedis 框架使用为例）：

import redis.clients.jedis.jedis;  
import redis.clients.jedis.jedispubsub;  
  
public class rediskeyspacenotifier {  
  
    public static void main(string[] args) {  
        // 创建jedis实例  
        jedis jedis = new jedis("localhost", 6379);  
  
        // 配置键空间通知（通常这一步在redis配置文件中完成，但也可以在运行时配置）  
        jedis.configset("notify-keyspace-events", "kea");  
  
        // 订阅键空间通知  
        jedis.subscribe(new keyspacenotificationsubscriber(), "__keyevent@0__:expired");  
    }  
  
    static class keyspacenotificationsubscriber extends jedispubsub {  
  
        @override  
        public void onmessage(string channel, string message) {  
            system.out.println("received message from channel: " + channel + ", message: " + message);  
            // 在这里处理接收到的键空间通知  
            // 例如，如果message是一个需要处理的任务id，你可以在这里触发相应的任务处理逻辑  
        }  
  
        @override  
        public void onsubscribe(string channel, int subscribedchannels) {  
            system.out.println("subscribed to channel: " + channel);  
        }  
  
        @override  
        public void onunsubscribe(string channel, int subscribedchannels) {  
            system.out.println("unsubscribed from channel: " + channel);  
        }  
    }  
}

但因为 redis 的 key 过期时不会被及时删除，redis 采用的是惰性删除和定期删除，所以这个过期事件也不保证可以立即触发，所以此方式很少用来实现延迟任务（因为极其不稳定）。

3.2. 使用zset实现延迟任务

可以将任务及其执行时间作为成员和分数存储在 zset 中，然后，使用一个后台任务（如定时任务或守护进程）定期检查 zset，查找分数（即执行时间）小于或等于当前时间的成员，并执行相应的任务。执行后，从 zset 中删除该成员，具体实现代码如下：

import redis.clients.jedis.jedis;  
  
import java.util.set;  
  
public class redisdelayedtaskdemo {  
  
    private static final string zset_key = "delayed_tasks";  
    private static final string redis_host = "localhost";  
    private static final int redis_port = 6379;  
  
    public static void main(string[] args) {  
        jedis jedis = new jedis(redis_host, redis_port);  
  
        // 添加延迟任务  
        adddelayedtask(jedis, "task1", system.currenttimemillis() / 1000 + 5); // 5秒后执行  
        adddelayedtask(jedis, "task2", system.currenttimemillis() / 1000 + 10); // 10秒后执行  
  
        // 模拟定时任务检查器  
        new thread(() -> {  
            while (true) {  
                try {  
                    // 检查并执行到期的任务  
                    checkandexecutetasks(jedis);  
                    thread.sleep(1000); // 每秒检查一次  
                } catch (interruptedexception e) {  
                    e.printstacktrace();  
                }  
            }  
        }).start();  
    }  
  
    private static void adddelayedtask(jedis jedis, string task, long executetime) {  
        jedis.zadd(zset_key, executetime, task);  
        system.out.println("added task: " + task + " with execution time: " + executetime);  
    }  
  
    private static void checkandexecutetasks(jedis jedis) {  
        long currenttime = system.currenttimemillis() / 1000;  
        set<string> tasks = jedis.zrangebyscore(zset_key, 0, currenttime);  
  
        for (string task : tasks) {  
            jedis.zrem(zset_key, task); // 从有序集合中移除任务  
            executetask(task); // 执行任务  
        }  
    }  
  
    private static void executetask(string task) {  
        system.out.println("executing task: " + task);  
        // 在这里添加实际的任务执行逻辑  
    }  
}

在这个示例中，我们首先使用 adddelayedtask 方法向 redis 的有序集合中添加任务，并设置它们的执行时间。然后，我们启动一个线程来模拟定时任务检查器，它会每秒检查一次是否有任务到期，并执行到期的任务。

3.3 使用redisson的延时队列(常用)

在 redisson 框架中，提供了一个 rdelayedqueue 用于实现延迟队列，使用简单方便，推荐使用，它的具体实现如下：

import org.redisson.redisson;
import org.redisson.api.rdelayedqueue;
import org.redisson.api.redissonclient;
import org.redisson.config.config;
 
import java.util.concurrent.timeunit;
 
public class rdelayedqueuedemo {
 
    public static void main(string[] args) throws interruptedexception {
        // 创建 redisson 客户端
        config config = new config();
        config.usesingleserver().setaddress("redis://127.0.0.1:6379");
        redissonclient redisson = redisson.create(config);
 
        // 获取延迟队列
        rdelayedqueue<string> delayedqueue = 
            redisson.getdelayedqueue("delayedqueue");
 
        // 添加延迟任务
        delayedqueue.offer("task1", 5, timeunit.seconds);
 
        // 监听并处理延迟任务
        thread listenerthread = new thread(() -> {
            while (true) {
                try {
                    // 通过 take 方法等待并获取到期的任务
                    string task = delayedqueue.take();
                    system.out.println("handle task: " + task);
                } catch (interruptedexception e) {
                    break;
                }
            }
        });
        listenerthread.start();
    }
}

在上述示例中，我们首先创建了一个 redisson 客户端，通过配置文件指定了使用单节点 redis 服务器。然后，我们获取一个延迟队列 rdelayedqueue，并添加一个延迟任务，延迟时间为 5 秒，接着，我们通过线程监听并处理延迟队列中的任务。

4.redis实现延迟任务优缺点分析

优点：

轻量级与高性能：redis 是一个内存中的数据结构存储系统，因此读写速度非常快。将任务信息存储在 redis 中可以迅速地进行存取操作。
简单易用：redis 的 api 简洁明了，易于集成到现有的应用系统中。

缺点：

精度有限：redis 的延迟任务依赖于系统的定时检查机制，而不是精确的定时器。这意味着任务的执行可能会有一定的延迟，特别是在系统负载较高或检查间隔较长的情况下。
功能有限：与专业的任务调度系统相比，redis 提供的延迟任务功能可能相对简单。对于复杂的任务调度需求，如任务依赖、任务优先级等，可能需要额外的逻辑来实现。
稳定性较差：使用 redis 实现延迟任务没有重试机制和 ack 确认机制，所以稳定性比较差。
单点故障风险：如果没有正确配置 redis 集群或主从复制，那么单个 redis 实例的故障可能导致整个延迟任务系统的瘫痪。