Redis-06队列与异步处理

最新推荐文章于 2025-12-19 14:33:51 发布

原创最新推荐文章于 2025-12-19 14:33:51 发布 · 832 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#redis #java

06 队列与异步处理

🎯 学习要点

列表队列与阻塞消费
Stream 消费者组与重试
延迟队列与定时任务
发布订阅通知

📖 名词解释

队列：先进先出消息结构，常用 List 实现。
阻塞消费：消费者在无消息时等待直至超时或有消息到来。
Stream：Redis 的消息流结构，支持多消费者与确认机制。
消费者组：Stream 的分组消费模式，组内多个消费者共享消息。
确认（ACK）：消费者处理完消息后进行确认，避免重复投递。
死信：未能成功处理或超时未确认的消息，需转入专用队列处理。
延迟队列：按时间延迟执行的队列，常用 ZSet 的分数存时间戳。
发布订阅：即发即收的消息模型，不保证持久化与重试。

🧭 学习方案

用 List 实现一个最小订单队列，生产与阻塞消费，处理超时与空队列。
用 Stream 创建消费者组，生产消息并实现确认，模拟失败重试。
用 ZSet 实现延迟取消订单任务，编写到期扫描流程并加去重。
使用发布订阅完成群聊通知或系统广播，理解其非持久化的特点。

🗺️ 应用场景说明

订单处理：下单后入队，后台异步扣库存与发货，提升接口响应速度。
通知中心：用户操作后推送消息到多个消费者，例如短信与站内信并行。
定时任务：30 分钟未支付自动取消，用 ZSet 保证到期执行。

⚠️ 注意事项

队列消息幂等与重试
延迟扫描并发安全
消费者确认机制

📥 列表队列

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.data.redis.core.RedisTemplate;
import java.time.Duration;

@Service
public class ListQueue {
    @Autowired
    RedisTemplate<String, String> tpl; 

    public void produce(String id) {
        // 生产者左入队，保证 FIFO；队列名按业务维度命名
        tpl.opsForList().leftPush("queue:orders", id);
    }

    public String consume() {
        // 阻塞消费，超时 2 秒；返回 null 表示空队列需重试或补偿
        return tpl.opsForList().rightPop("queue:orders", Duration.ofSeconds(2));
    }
}

通俗说明

生产者“左推”，消费者“右取”，保证先入先出，像排队取号。
阻塞消费就像“等消息”，超时返回空，需要业务层做重试或补偿。
队列消息要考虑幂等处理，防止重复消费导致重复扣减或发送。

详细解释

写入 LPUSH，读取 BRPOP 可阻塞等待消息到来并设置超时。
幂等通过业务 ID 去重或状态机控制，保证重复消息不会重复执行。
长队列建议分桶或限长，避免形成大 Key 影响性能与扫描。

速记口诀

口诀：左入右出，阻塞要幂等

👥 Stream 消费者组

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.connection.stream.MapRecord;
import org.springframework.data.redis.connection.stream.ReadOffset;
import org.springframework.data.redis.connection.stream.Consumer;
import org.springframework.data.redis.connection.stream.StreamOffset;
import java.util.Map;

@Service
public class StreamGroup {
    @Autowired
    RedisTemplate<String, String> tpl; 

    public void init() {
        // 创建消费者组 g1，从最初偏移 "0-0" 开始；若已存在则忽略异常
        try { 
        	tpl.opsForStream().createGroup("stream:orders", ReadOffset.from("0-0"), "g1"); 
        } catch (Exception ignored) {
        }
    }

    public void produce() {
        // 生产一条消息到 Stream，键值为 {id: O1001}
        tpl.opsForStream().add(MapRecord.create("stream:orders", Map.of("id", "O1001")));
    }

    public Object consume() {
        // 以组 g1 的消费者 c1 从最后消费偏移继续读取，避免重复
        return tpl.opsForStream().read(Consumer.from("g1", "c1"), StreamOffset.create("stream:orders", ReadOffset.lastConsumed()));
    }
}

通俗说明

创建消费者组后，消息会分配到组内消费者，处理完要确认（ACK）。
读取偏移要根据场景选择：从未读、最后已消费处继续、或指定 ID。

详细解释

初始化组后用 lastConsumed 继续消费，避免重复；处理完成要 ACK。
失败消息进入待处理队列（PENDING），需按需转移或重试。
组内分配提升并发处理能力，但要注意公平性与负载均衡。

⏰ 延迟队列（ZSet）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.Set;

@Service
public class DelayQueueZSet {
    @Autowired
    RedisTemplate<String, String> tpl; // 模板用于操作 ZSet 延迟队列

    public void schedule(String orderId, long delayMs) {
        // 计算触发时间戳，作为 ZSet 分数存入
        long at = System.currentTimeMillis() + delayMs;
        tpl.opsForZSet().add("delay:orders", orderId, at);
    }

    public void scanDue() {
        // 查询到期任务，再删除确保幂等后处理
        Set<String> due = tpl.opsForZSet().rangeByScore("delay:orders", 0, System.currentTimeMillis());
        if (due != null) {
            for (String id : due) {
                // 删除成功表示本实例拿到任务
                Long removed = tpl.opsForZSet().remove("delay:orders", id);
                if (removed != null && removed > 0) {
                    process(id);
                }
            }
        }
    }

    private void process(String id) {
        String s = id; // 替换为实际业务处理逻辑
    }
}

通俗说明

用时间戳作为分数，实现“到期执行”的延迟任务。
扫描时先查询再删除，配合去重避免重复处理。

详细解释

分数即为触发时间戳，按 rangeByScore 查到期项，再 remove 去重处理。
并发扫描需加互斥或原子删除，避免多实例重复处理同一任务。
适合到期取消订单、超时关闭会话等场景。

📣 发布订阅（Spring）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.listener.ChannelTopic;

@Configuration
public class PubSubConfig {
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory factory) {
        // 创建监听容器
        RedisMessageListenerContainer c = new RedisMessageListenerContainer();
        // 绑定连接工厂 
        c.setConnectionFactory(factory); 
        // 适配消息监听回调，订阅频道 chat:family
        c.addMessageListener(new MessageListenerAdapter((MessageListener) (message, pattern) -> {}), new ChannelTopic("chat:family"));
        return c;
    }
    interface MessageListener {
        // 处理订阅到的消息
        void onMessage(byte[] message, byte[] pattern); 
    }
}

通俗说明

发送端通过频道发布消息，订阅者即时接收；没有历史消息回放。
适合系统通知与群聊提醒，不适合可靠投递。

详细解释

发布订阅是“即发即收”，离线不会补发，适合作轻量通知。
监听回调里尽量做轻逻辑，复杂流程交给队列或任务系统。
频道命名需规范，避免与其他业务冲突。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.data.redis.core.RedisTemplate;

@Component
public class PubSubSender {
    @Autowired
    RedisTemplate<String, String> tpl; 
    public void send() { 
        // 发布到频道 chat:family
        tpl.convertAndSend("chat:family", "晚饭开饭"); 
    } 
}

通俗说明

发送端通过频道发布消息，订阅者即时接收；没有历史消息回放。
适合系统通知与群聊提醒，不适合可靠投递。

详细解释

发送用 convertAndSend(channel, msg)；订阅端需在线才能收到消息。
不保证持久化与重试，重要消息用队列或事务型存储保障可靠性。
适合作公告、群聊提醒等轻量场景。

🧰 Redisson 队列与延迟队列

原理

RQueue 作为共享队列供多实例读写；RBlockingQueue 支持阻塞获取以降低空轮询开销。
RDelayedQueue 绑定目标队列并保存到期时间，到期后将元素投递回目标队列，无需人工扫描。

import org.redisson.api.RedissonClient;
import org.redisson.api.RQueue;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RBlockingQueue;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class RedissonQueues {
    @Autowired
    RedissonClient client; 

    public void pushNow(String item) {
        // 共享队列，队列名按业务维度命名
        RQueue<String> q = client.getQueue("rqueue:orders"); 
        // 立即投递到队列，供消费者消费
        q.add(item); 
    }

    public void delay(String item, long delay, TimeUnit unit) {
        // 目标队列，延迟到期后自动入此队
        RQueue<String> q = client.getQueue("rqueue:orders"); 
        // 绑定延迟队列到目标队列
        RDelayedQueue<String> dq = client.getDelayedQueue(q); 
        // 延迟投递，时间精度由 unit 决定
        dq.offer(item, delay, unit); 
    }

    public String poll() {
        // 非阻塞消费
        RQueue<String> q = client.getQueue("rqueue:orders"); 
        // 空队列返回 null，适合轮询+退避策略
        return q.poll(); 
    }

    public String takeBlocking() throws InterruptedException {
        // 阻塞队列，等待直到有元素
        RBlockingQueue<String> bq = client.getBlockingQueue("rqueue:orders");
        // 阻塞获取，适合常驻消费者线程，避免空轮询
        return bq.take(); 
    }

    public void cleanup() {
        RQueue<String> q = client.getQueue("rqueue:orders");
        // 获取与目标队列绑定的延迟队列结构
        RDelayedQueue<String> dq = client.getDelayedQueue(q); 
        // 释放延迟队列内部结构，应用关闭或重建队列名时调用
        dq.destroy(); 
    }
}