redis-实现消息队列功能

最新推荐文章于 2025-04-16 15:19:31 发布
最新推荐文章于 2025-04-16 15:19:31 发布
阅读量1.5k 收藏
点赞数
分类专栏： redis 文章标签： redis rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_37520037/article/details/120807858
版权
Redis 提供了发布订阅模式，但不保证消息可靠性。为解决此问题，Redis 引入 Stream 数据类型，结合消费者群组实现可靠的消息队列。通过 xadd, xread, xgroup 等命令管理 Stream，并使用 xack 确认消息消费。" 125156466,11883219,软件项目管理概览,"['项目管理', '需求分析', '成本估算', '进度控制', '软件配置管理']

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

发布与订阅

    Redis提供了"发布、订阅"模式的消息机制，其中消息订阅者与发布者不直接通信，发布者向指定的频道(channel)发送消息，订阅者从频道拿取消息。

pubsub简单命令介绍

  • publish [频道] [消息] 如 publish test yu
    在这里插入图片描述

  • subscribe [频道] 订阅某个频道的消息
    在这里插入图片描述

  • pubsub numsub [频道] 查看订阅数

  • unsubscribe [频道] 取消订阅

  • psubscribe ch* 按模式订阅

  • punsubscribe ch* 按模式取消订阅
    注意：这种方式是一种发送既忘的原则，如果发送时没有消费者订阅，消息就会丢失，pub/sub作为消息中间件时不能保证消息的可靠。保证消息的可靠性时，不能作为选择。Redis后续推出了Stream的发布订阅功能。

基于stream的发布与订阅

    可以使用消费者群组来消费，last_delivered_id来标识该消费者群组消费到了消息的哪个位置。一个消费者群组内部消费者可以有多个，且一个消息仅能被一个消费者群组下面的一个消费者消费。消息的确认ACK，确保消息一定被消费成功。pending_ids[]标识消息已经被消费者拿到了，但是消费者还没有做应答，如果一直不做应答，这个pending_ids（Pending Entries List）会越来越长，不支持消费超时，死信队列。
在这里插入图片描述
消息id: 毫秒时间戳-序号 表示消息是在这个时间戳产生的第几个。
Message Conent: 消息内容，String

基于Stream的操作

  • xadd [stream] * [key] [value]…
    *表示消息id由redis生成 stream 为stream名称，返回值为消息id，即使出现了时钟回拨，Last_generated_id 记录最大的id,会使-后面的数字+1，也不会导致重复。
    在这里插入图片描述

  • xlen [stream] 查看stream中消息个数
    在这里插入图片描述

  • xrange [stream] - + 查看stream中所有消息
    -和+可以替换为对应的消息id
    在这里插入图片描述

  • xdel [stream] [消息id] 删除stream中的指定消息
    在这里插入图片描述
    支持消费者群组，同时也支持单消费者，单消费者用来保证消息的顺序性。

  • xread count 1 streams [stream] 0-0 表示从头开始消费一条消息

  • xread count 1 streams [stream] 消息id 指定id开始

  • xread count 1 streams [stream] $ 从尾部读取消息

  • xread block 0 count 1 streams [stream] $ 阻塞式从尾部读取
    在这里插入图片描述
    消费者群组

  • xgroup create [stream] [group] 0-0

  • xgroup create [stream][group] $
    在这里插入图片描述

  • xinfo groups [stream]
    查看消费者群组的信息

  • xreadgroup GROUP [group] [consumer] count [n] streams [stream] >
    创建一个消费者 group 消费者群组名称 , consumer 消费者名称 stream stream名称 > 从哪一个开始读取
    在这里插入图片描述
    xreadgroup GROUP cg1 c1 block 0 count 1 streams stream:test > 阻塞式读取
    xinfo consumers [stream] [group]
    查看消费者群组中的信息
    在这里插入图片描述

  • xack [stream] [consumer] [消息id]
    确认一条消息
    在这里插入图片描述

  • xclaim 把消息在多个消费者之间转移

  • xpending [stream] [group] 查看未ack的消息

redis实现消息队列的方式
  1. 可通过队列实现 lpush brpop
@Component
public class ListVer {

    public static final String RS_LIST_MQ_NS = "rs:list:mq";

    @Autowired
    private JedisPool jedisPool;

    /**
     * 发送消息
     * @param key
     * @param message
     */
    public void put(String key, String message) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.lpush(RS_LIST_MQ_NS+key, message);
        } catch (Exception ex) {
            throw new RuntimeException("发送消息失败");
        } finally {
            jedis.close();
        }
    }

    /**
     * 获取消息
     * @param key
     * @return
     */
    public List<String> get(String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            return jedis.brpop(0,RS_LIST_MQ_NS+key);
        }catch (Exception ex){
            throw new RuntimeException("获取消息失败");
        }finally {
            jedis.close();
        }
    }
}
  1. 通过zset实现 一般是延时队列
@Component
public class ZsetVer {
    public static final String RS_ZSET_MQ = "rs:zset:mq";

    @Autowired
    private JedisPool jedisPool;

    /**
     * 发送消息
     *
     * @param key     key
     * @param message 消息内容
     */
    public void sendMsg(String key, String message) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            for (int i = 0; i < 5; i++) {
                String orderNo = "000000000" + i;
                double expireTime = System.currentTimeMillis() + (i * 1000);
                jedis.zadd(RS_ZSET_MQ + key, expireTime, orderNo);
            }
        } catch (Exception ex) {
            throw new RuntimeException("发送延迟消息失败");
        } finally {
            jedis.close();
        }
    }

    /**
     * 消费消息 基于zRange 和 Zrem
     * @param key
     */
    public void getMsg(String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            while (true){
                Set<String> strings = jedis.zrangeByScore(RS_ZSET_MQ + key, 0, System.currentTimeMillis());
                if(strings == null || strings.size() == 0){
                    Thread.sleep(1000);
                    continue;
                }
                String s = strings.iterator().next();
                if(jedis.zrem(RS_ZSET_MQ+key, s) > 0){
                    // 业务逻辑处理，这里删除的线程只有一个，所以只有一个可以处理到，不存在线程安全问题
                    System.out.println(s);
                }
            }
        }catch (Exception ex){
            throw new RuntimeException("消费消息失败");
        }finally {
            jedis.close();
        }
    }
}
  1. 通过pubsub实现 可能丢失消息
@Component
public class PSVer extends JedisPubSub {

    public final static String RS_PS_MQ_NS = "rpsm:";

    @Autowired
    private JedisPool jedisPool;

    @Override
    public void onMessage(String channel, String message) {
        System.out.println("Accept " + channel + ",message:" + message);
    }

    @Override
    public void onSubscribe(String channel, int subscribedChannels) {
        System.out.println("Subscribe " + channel + ", count:" + subscribedChannels);
    }

    public void publish(String channel, String message) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.publish(RS_PS_MQ_NS + channel, message);
            System.out.println("发送消息 " + RS_PS_MQ_NS + channel + " message=" + message);
        } catch (Exception e) {
            throw new RuntimeException("发布消息失败!");
        } finally {
            jedis.close();
        }
    }

    @Override
    public void subscribe(String... channels) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            jedis.subscribe(this, channels);
        } catch (Exception e) {
            throw new RuntimeException("订阅频道失败");
        } finally {
            jedis.close();
        }
    }
}
  1. 通过stream实现
@Component
public class StreamVer {
    public final static String RS_STREAM_MQ_NS = "rsm:";

    @Autowired
    private JedisPool jedisPool;

    public final static int MQ_INFO_CONSUMER = 1;
    public final static int MQ_INFO_GROUP = 2;
    public final static int MQ_INFO_STREAM = 0;

    /**
     * 发送消息
     *
     * @param key     stream名称
     * @param message 消息
     * @return 消息id
     */
    public StreamEntryID produce(String key, Map<String, String> message) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            StreamEntryID streamId = jedis.xadd(RS_STREAM_MQ_NS + key, StreamEntryID.NEW_ENTRY, message);
            System.out.println("发送消息到 " + RS_STREAM_MQ_NS + "key, 消息id:" + streamId);
            return streamId;
        } catch (Exception e) {
            throw new RuntimeException("发布消息失败!");
        } finally {
            jedis.close();
        }
    }

    /**
     * 创建消费者群组
     *
     * @param key             stream名称
     * @param groupName       group名称
     * @param lastDeliveredId 群组最后一个消息id
     */
    public void createConsumerGroup(String key, String groupName, String lastDeliveredId) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            StreamEntryID id = null;
            if (lastDeliveredId == null) {
                lastDeliveredId = "0-0";
            }
            id = new StreamEntryID(lastDeliveredId);
            // makeStream表示没有时是否自动创建stream,但是如果有，再自动创建会异常
            jedis.xgroupCreate(RS_STREAM_MQ_NS + key, groupName, id, false);
            System.out.println("创建消费者群组成功");
        } catch (Exception e) {
            throw new RuntimeException("创建消费者群组失败");
        } finally {
            jedis.close();
        }
    }

    /**
     * 消息消费
     *
     * @param key          stream名称
     * @param consumerName
     * @param groupName
     * @return
     */
    public List<Map.Entry<String, List<StreamEntry>>> consume(String key, String consumerName, String groupName) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            XReadGroupParams readGroupParams = new XReadGroupParams().block(0).count(1);
            Map<String, StreamEntryID> params = new HashMap<>();
            params.put(RS_STREAM_MQ_NS + key, StreamEntryID.UNRECEIVED_ENTRY);
            List<Map.Entry<String, List<StreamEntry>>> result = jedis.xreadGroup(groupName, consumerName, readGroupParams, params);
            System.out.println(groupName + "从" + RS_STREAM_MQ_NS + key + "接收消息，返回消息：" + result);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("消息消费失败");
        } finally {
            jedis.close();
        }
    }

    /**
     * 消息确认
     *
     * @param key
     * @param groupName
     * @param msgId
     */
    public void ackMsg(String key, String groupName, StreamEntryID msgId) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            System.out.println(jedis.xack(RS_STREAM_MQ_NS + key, groupName, msgId));
            System.out.println(RS_STREAM_MQ_NS + key + ",群组 group:" + groupName + "消息已确认");
        } catch (Exception e) {
            throw new RuntimeException("确认失败");
        } finally {
            jedis.close();
        }
    }

}
Redis实现消息队列
悦分享
09-02 3031
1）Redis中实现生产者和消费者模型，可使用LPUSH和RPOP来实现该功能。不过当列表为空时消费者就需要轮询来获取消息，这样会增加Redis的访问压力和消费者的CPU时间，另外很多访问也是无用的。为此Redis提供了阻塞式访问BRPOP和BLPOP命令。同时Redis会为所有阻塞的消费者以先后顺序排序。2）使用Redis的列表来实现一个任务队列，开启两个程序，一个作为生产者使用LPUSH写队列，一个作为消费者使用RPOP读队列。由于消费者并不知道什么时候会有消息过来，所以消费者需要一直循环读取数据。
利用Redis 实现消息队列
guoduhua的专栏
02-13 2589
版权声明：本文为博主原创文章，未经博主允许不得转载。 目录(?)[+] 1.用redis中的List可以实现队列，这样可以用来做消息处理和任务调度的队列 2.代码模拟 代码结构 生产者模拟程序 [java] view plain copy /**   *    
Redis——Redis实战：7 Redis消息队列
最新发布
kongbaidemumu的博客
04-16 895
讲解了Redis的消息队列、基于List结构模拟消息队列、于PubSub的消息队列、基于Stream的消息队列、消费者组、三者的对比，最后实现基于Stream的消息队列实现异步秒杀下单。
redis 队列功能
weixin_33976072的博客
03-02 125
2019独角兽企业重金招聘Python工程师标准>>> ...
Redis 实现消息队列
Mwt258的博客
08-07 5662
【Redis】介绍如何利用redis实现消息队列(超详细)
Redis消息队列
耀灵的博客
03-22 8730
Redis提供了三种不同的方式来实现消息队列： list结构：基于List结构模拟消息队列 PubSub：基本的点对点消息模型 Stream：比较完善的消息队列模型 1. 基于List结构模拟消息队列 LPUSH 结合 RPOP、或者 RPUSH 结合 LPOP来实现。 不过要注意的是，当队列中没有消息时RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。因此这里应该使用BRPOP或者BLPOP来实现阻塞效果。 优点： 利用Redis存储，不受限于JVM内存.
redis-6.2.14-win-amd64
05-22
Redis是一种开源的、基于键值对的数据存储系统，常用于数据缓存、消息队列以及数据库功能。在Windows环境下，Redis的安装和使用通常需要经过编译和配置过程。"redis-6.2.14-win-amd64"是专门为Windows AMD64架构编译...
Redis-x64-5.0.14.1 Windows版
09-06
Redis的多样数据结构和出色的性能使得它可以在多种场景中发挥作用，如：缓存系统（减少数据库的负担）、会话存储（Web应用中用于存储用户会话信息）、排行榜和实时计数（如社交平台上的点赞、评论计数）、消息队列...
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
文章提到了MQ、RabbitMQ、RocketMQ、Kafka等其他消息中间件，但本文主要聚焦于Redis的消息队列功能。 二、基于Redis List实现消息队列 Redis的List数据结构可以模拟消息队列，通过LPUSH/RPOP、RPUSH/LPOP操作进行...
redis-windows-7.2.5.zip
05-20
- **发布/订阅**：Redis的pub/sub机制允许实现消息传递和事件驱动架构。 2. **Windows安装** - 下载：从官方网站或者镜像站点获取最新版本的"redis-windows-7.2.5.zip"。 - 解压：将压缩包解压到任意目录，例如...
Redis-x64-3.2.100.zip
10-10
5. **发布/订阅**：Redis支持发布订阅模式，允许客户端订阅特定的频道，当有消息发布到这些频道时，所有订阅者都会收到通知，这使得Redis可以用作简单的消息队列。 6. **Lua脚本**：Redis内置了对Lua脚本的支持，...
21-Redis 中如何实现的消息队列？实现的方式有几种？
cenghaihengliu的博客
06-22 1159
细心的你可能发现了，本系列课程中竟然出现了三个课时都是在说消息队列，第 10 课时讲了程序级别的消息队列以及延迟消息队列的实现，而第 15 课时讲了常见的消息队列中间件 RabbitMQ、Kafka 等，由此可见消息队列在整个 Java 技术体系中的重要程度。本课时我们将重点来看一下 Redis 是如何实现消息队列的。 我们本课时的面试题是，在 Redis 中实现消息队列的方式有几种？ 典型回答 早在 Redis 2.0 版本之前使用 Redis 实现消息队列的方式有两种： 使用 List 类型实现 使用
redis做消息队列功能
sinat_37627782的博客
12-23 345
之前研究了一下两个MQ，这俩挺靠谱的。倒是有个B说他们用的是redis的消息的订阅来做的队列，我挺好奇的于是乎在网上抄了一份，这个东西挺快的但是可能会丢数据可靠性比消息队列差，从体量上来说感觉就也很好理解。 这个功能貌似主要基于redis的List功能，这个结构可以模拟队列（先进先出）和栈（先进后出） 这个例子一开始是单纯的使用lpush插入和rpop取出的的方法实现的，但是这个方式在创建时没...
redis实现消息队列
shigen的博客
09-08 1435
Stream 可以看作是一个由消息组成的日志，每个消息都有一个唯一的 ID（可以是时间戳或其他方式生成），并且可以对消息进行按照时间的顺序和优先级进行排序。它解耦了发送消息的应用程序和接收消息的应用程序之间的直接依赖关系，使得消息的发送者和接收者可以独立地演化和扩展。消息不能防止重复消费：Redis 的 pub/sub 模式不支持消息的确认和回调机制，因此，当订阅者收到消息时，无法对其进行确认，也就无法防止重复消费。相信在做分布式服务开发的时候，或多或少的使用到了消息队列，如主流的。
利用Redis实现消息队列jizq-redis-mq的设计与应用
在消息队列方面，Redis可以作为发布/订阅模式的消息系统，也可以用来实现队列（如使用List数据结构来实现简单的队列，或者使用Sorted Set来实现优先级队列）。 从给出的标题和描述中，我们可以推断出以下几点知识：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值