Redis 消息队列：实现、操作与性能优化

于 2024-10-10 13:35:57 发布
阅读量770 收藏 8
点赞数 4
分类专栏： Redis开发者手册 消息队列 文章标签： redis 性能优化 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43319056/article/details/142819253
版权

Redis 是一个高性能的内存数据库，支持多种数据结构，特别适合用于实现消息队列。本文将详细介绍如何使用 Redis 的 List 数据结构实现一个简单而高效的消息队列系统，包括消息队列的基本操作、示例代码以及优化建议。

一，消息队列简介

消息队列是一种用于在分布式系统中实现异步通信的机制。它允许不同的系统组件之间通过发送和接收消息进行通信，而无需直接调用彼此的接口。消息队列的常见应用场景包括任务调度、日志处理、事件通知等。

二，Redis List 数据结构

Redis 的 List 数据结构是一个双向链表，支持从两端插入和删除元素。常用的 List 命令包括：

  • LPUSH：从左侧插入元素。
  • RPUSH：从右侧插入元素。
  • LPOP：从左侧弹出元素。
  • RPOP：从右侧弹出元素。
  • BRPOP：阻塞式从右侧弹出元素。
  • BLPOP：阻塞式从左侧弹出元素。

三，实现消息队列的基本操作

1. 生产者（Producer）

生产者负责将消息发送到队列中。使用 LPUSH 或 RPUSH 命令将消息插入到 Redis 列表中。

import redis.clients.jedis.Jedis;

public class Producer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public Producer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 发送消息
    public void sendMessage(String message) {
        jedis.rpush(queueKey, message);
    }

    public static void main(String[] args) {
        Producer producer = new Producer();
        producer.sendMessage("Hello, World!");
        System.out.println("Message sent: Hello, World!");
    }
}

2. 消费者（Consumer）

消费者负责从队列中接收消息。使用 LPOP 或 RPOP 命令从 Redis 列表中弹出消息。

import redis.clients.jedis.Jedis;

public class Consumer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public Consumer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 接收消息
    public String receiveMessage() {
        return jedis.lpop(queueKey);
    }

    public static void main(String[] args) {
        Consumer consumer = new Consumer();
        String message = consumer.receiveMessage();
        System.out.println("Message received: " + message);
    }
}

3. 阻塞式消费者

使用 BLPOP 或 BRPOP 命令实现阻塞式消费者，当队列为空时，消费者会阻塞等待直到有新消息到达。

import redis.clients.jedis.Jedis;

public class BlockingConsumer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public BlockingConsumer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 阻塞式接收消息
    public String receiveMessage() {
        return jedis.blpop(0, queueKey).get(1);
    }

    public static void main(String[] args) {
        BlockingConsumer consumer = new BlockingConsumer();
        String message = consumer.receiveMessage();
        System.out.println("Message received: " + message);
    }
}

四，示例代码

以下是一个完整的示例代码，展示了如何使用 Redis 实现一个简单的消息队列系统，包括生产者和消费者。

import redis.clients.jedis.Jedis;

public class Producer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public Producer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 发送消息
    public void sendMessage(String message) {
        jedis.rpush(queueKey, message);
    }

    public static void main(String[] args) {
        Producer producer = new Producer();
        producer.sendMessage("Hello, World!");
        System.out.println("Message sent: Hello, World!");
    }
}

import redis.clients.jedis.Jedis;

public class Consumer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public Consumer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 接收消息
    public String receiveMessage() {
        return jedis.lpop(queueKey);
    }

    public static void main(String[] args) {
        Consumer consumer = new Consumer();
        String message = consumer.receiveMessage();
        System.out.println("Message received: " + message);
    }
}

import redis.clients.jedis.Jedis;

public class BlockingConsumer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public BlockingConsumer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 阻塞式接收消息
    public String receiveMessage() {
        return jedis.blpop(0, queueKey).get(1);
    }

    public static void main(String[] args) {
        BlockingConsumer consumer = new BlockingConsumer();
        String message = consumer.receiveMessage();
        System.out.println("Message received: " + message);
    }
}

五，优化建议

在使用Redis实现消息队列时，可以通过以下优化方法来提高系统的性能和可靠性：

1. 使用管道（Pipeline）

当需要批量发送或接收消息时，可以使用管道（Pipeline）来减少网络延迟，提高性能。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;

import java.util.List;

public class Producer {

    private Jedis jedis;
    private String queueKey = "messageQueue";

    public Producer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 批量发送消息
    public void sendMessages(List<String> messages) {
        Pipeline pipeline = jedis.pipelined();
        for (String message : messages) {
            pipeline.rpush(queueKey, message);
        }
        pipeline.sync();
    }

    public static void main(String[] args) {
        Producer producer = new Producer();
        List<String> messages = List.of("Message 1", "Message 2", "Message 3");
        producer.sendMessages(messages);
        System.out.println("Messages sent: " + messages);
    }
}

2. 使用持久化

为了防止Redis实例重启或崩溃导致的数据丢失，可以启用Redis的持久化功能，如RDB快照或AOF日志。

在redis.conf文件中启用持久化：

# RDB快照
save 900 1
save 300 10
save 60 10000

# AOF日志
appendonly yes

3. 使用分布式锁

在高并发环境中，可能会出现多个消费者同时处理同一条消息的问题。可以使用Redis的分布式锁来确保消息的唯一消费。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;

public class Consumer {

    private Jedis jedis;
    private String queueKey = "messageQueue";
    private String lockKey = "lockKey";
    private int lockTimeout = 30000; // 30秒

    public Consumer() {
        jedis = new Jedis("localhost", 6379);
    }

    // 获取分布式锁
    private boolean acquireLock(String lockKey, String requestId, int expireTime) {
        SetParams params = new SetParams();
        params.nx().px(expireTime);
        String result = jedis.set(lockKey, requestId, params);
        return "OK".equals(result);
    }

    // 释放分布式锁
    private void releaseLock(String lockKey, String requestId) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                        "return redis.call('del', KEYS[1]) else return 0 end";
        jedis.eval(script, List.of(lockKey), List.of(requestId));
    }

    // 接收消息
    public String receiveMessage() {
        String requestId = String.valueOf(System.currentTimeMillis());
        if (acquireLock(lockKey, requestId, lockTimeout)) {
            try {
                return jedis.lpop(queueKey);
            } finally {
                releaseLock(lockKey, requestId);
            }
        }
        return null;
    }

    public static void main(String[] args) {
        Consumer consumer = new Consumer();
        String message = consumer.receiveMessage();
        System.out.println("Message received: " + message);
    }
}

4. 使用分片（Sharding）

对于大规模的消息队列，可以使用分片技术，将消息分布到多个Redis实例中，减少单个实例的压力。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;

import java.util.ArrayList;
import java.util.List;

public class ShardedProducer {

    private ShardedJedis shardedJedis;
    private String queueKey = "messageQueue";

    public ShardedProducer() {
        List<JedisShardInfo> shards = new ArrayList<>();
        shards.add(new JedisShardInfo("localhost", 6379));
        shards.add(new JedisShardInfo("localhost", 6380));
        shardedJedis = new ShardedJedis(shards);
    }

    // 发送消息
    public void sendMessage(String message) {
        shardedJedis.rpush(queueKey, message);
    }

    public static void main(String[] args) {
        ShardedProducer producer = new ShardedProducer();
        producer.sendMessage("Hello, Sharded World!");
        System.out.println("Message sent: Hello, Sharded World!");
    }
}

通过以上优化建议，开发者可以进一步提升Redis消息队列系统的性能和可靠性，确保在高并发和大数据量的情况下依然能够高效运行。

Redis 做消息队列
永远年轻
04-25 462
Redis 做消息队列1. Redis 做消息队列1.1 消息队列1.2 延迟消息队列 1. Redis 做消息队列 我们平时说到消息队列，一般都是指 RabbitMQ、ActiveMQ、RocketMQ 以及大数据里的 KafKa，这些都是我们比较常见的消息中间件，也是非常专业的消息中间件，作为专业的中间见，它也提供了很多功能。 但是，当我们需要使用消息中间件的时候，我们要根据实际情况来选择，例...
Redis消息队列
耀灵的博客
03-22 8654
Redis提供了三种不同的方式来实现消息队列： list结构：基于List结构模拟消息队列 PubSub：基本的点对点消息模型 Stream：比较完善的消息队列模型 1. 基于List结构模拟消息队列 LPUSH 结合 RPOP、或者 RPUSH 结合 LPOP来实现。 不过要注意的是，当队列中没有消息时RPOP或LPOP操作会返回null，并不像JVM的阻塞队列那样会阻塞并等待消息。因此这里应该使用BRPOP或者BLPOP来实现阻塞效果。 优点： 利用Redis存储，不受限于JVM内存.
redis消息队列
jifgnie的博客
07-19 294
四、Redis Streams的示例。三 、列表（List）模式代码示例。
Redis实现消息队列
m0_74267125的博客
04-06 1128
消息队列（Message Queue）是一种通信方式，用于在不同应用程序或不同组件之间传递消息。它允许发送者（生产者）将消息发送到队列中，然后接收者（消费者）可以从队列中获取消息进行处理。消息队列通常用于解耦系统的不同部分，提高系统的可扩展性、可靠性和性能。消息队列的基本原理是，消息发送者将消息发送到队列中，而消息接收者则从队列中获取消息。发送者和接收者之间不直接通信，而是通过队列来传递消息。
【Redis】redis做消息队列
opt_cody的博客
10-12 487
应用场景： 例如秒杀。瞬时大量写入订单到数据库，导致数据库无法及时响应。此时可以采用Redis做消息队列，把所有需要写入的数据先写入Redis消息队列中，然后同时在服务器开启php-cli进程循环读取队列中的数据，异步写入数据库。使用redis做消息队列可能会出现消息丢失的情况，因为没有消息接收的确认机制。大型程序，应该使用类似RabitMQ来做专业消息队列。 1、使用publish/subs...
Redis深度历险：核心原理和应用实践【TALKDATA推荐】1
08-03
《Redis深度历险：核心原理和应用实践》是一本由钱文品老师编著的专业书籍，旨在深入探讨Redis这一流行...通过阅读本书，读者不仅能了解Redis的核心原理，还能学会如何在各种业务场景中有效地利用Redis来优化系统性能。
Redis深度历险：核心原理和应用实践.zip
02-27
Redis是一款高性能的键值存储系统，广泛应用于缓存、消息队列、计数器等多个场景。下面将详细探讨Redis的核心原理和常见应用实践。 1. **Redis核心原理**： - **数据结构**：Redis基于多种高效的数据结构，如字符...
NewLife.Redis:高性能Redis客户端，支持.NETCore.NET4.0.NET4.5，为大数据与消息队列而特别优化，线上单应用日均100亿调用量
04-29
Redis协议基础实现Redis/RedisClient位于，本库为扩展实现，主要增加列表结构、哈希结构、队列等高级功能。 源码： Nuget：NewLife.Redis 特性 在ZTO大数据实时计算广泛应用，200多个Redis实例稳定工作一年多，每天...
PHP基于Redis消息队列实现发布微博的方法
10-19
Redis是一个高性能的键值存储系统，常用于缓存、消息队列和其他数据结构服务。结合PHP，我们可以构建一个高效、低延迟的微博发布系统，有效降低数据库的并发压力。 首先，我们需要在服务器上安装Redis和PHP的Redis...
Qt 应用Redis 实现消息队列
11-03
本篇文章将详细讲解如何在Qt应用程序中利用Redis来实现一个高效的消息队列，以实现点对点的生产者-消费者模式。 首先，我们需要了解Qt和Redis的基础知识。Qt是一个跨平台的C++图形用户界面库，它提供了丰富的API...
redis 做消息队列
guoyilongedu的专栏
12-10 2427
因为游戏服务器开发中，有些比较耗时或者耗时不可控的操作，比如发送邮件，向第三方平台提交日志埋点，这些操作其实都可以后台操作，客户端就可以及时得到返回，提升用户体验。 1.redis 的安装　 2.php redis 扩展的安装 PHP 使用 Redis | 菜鸟教程 代码 RedisManager.php <?php class RedisManager { private static $instance; private static $redis_host =
Redis 作为消息队列
qq_45264366的博客
01-13 2829
Redis 作为消息队列消息队列消息保序重复消息处理消息可靠性保证List 作为消息队列Streams 的消息队列、 消息队列 消息队列在存取消息时，必须要满足三个需求，分别是消息保序、处理重复的消息和保证消息可靠性。 消息保序 虽然消费者是异步处理消息，但是，消费者仍然需要按照生产者发送消息的顺序来处理消息，避免后发送的消息被先处理了。对于要求消息保序的场景来说，一旦出现这种消息被乱序处理的情况，就可能会导致业务逻辑被错误执行，从而给业务方造成损失。 重复消息处理 消费者从消息队列读取消息时，有时会因为网
Redis 实现消息队列
最新发布
Mwt258的博客
08-07 3629
【Redis】介绍如何利用redis实现消息队列(超详细)
使用Redis做消息队列
qq_33867986的博客
05-18 242
基于List的 LPUSH+BRPOP 的实现 使用rpush和lpush操作入队列，lpop和rpop操作出队列。List支持多个生产者和消费者并发进出消息，每个消费者拿到都是不同的列表元素。但是当队列为空时，lpop和rpop会一直空轮训，消耗资源；所以引入阻塞读blpop和brpop（b代表blocking），阻塞读在队列没有数据的时候进入休眠状态， 一旦数据到来则立刻醒过来，消息延迟几乎为零。 PUB/SUB，订阅/发布模式 SUBSCRIBE，用于订阅信道 PUBLISH，向信道发送消息 UNSU
redis实现消息队列
weixin_47345703的博客
02-01 771
java 用 redis实现消息队列&发布/订阅模式使用 Redis的列表类型键可以用来实现队列，并且支持阻塞式读取，可以很容易的实现一个高性能的优先队列。同时在更高层面上，Redis还支持"发布/订阅"的消息模式，可以基于此构建一个聊天系统。 一、redis的列表类型天生支持用作消息队列。(类似于MQ的队列模型–任何时候都可以消费，一条消息只能消费一次) 　　list操作参考 在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样，我们可以在其头部(left)和尾部
探索消息队列基础：Redis与性能优化
首先，消息队列是一种分布式通信机制，它通过将消息发送到一个独立的中间件（如Redis或MQTT）来实现生产者和消费者之间的解耦，从而提高系统的可靠性和可扩展性。 文章中提到的"Tensor"? 和"Պ"? 字符可能是某种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

技术拾光者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值