Redis实现延迟任务的常见方案详解

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);  
        }  
    }  
}

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, "task两", 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);  
        // 正在那面加添实践的工作执止逻辑  
    }  
}

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://1二7.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();
    }
}