Golang-RabbitMQ 延迟队列的两种实现方法【详解】

已于 2023-08-19 15:36:36 修改
阅读量891 收藏 3
点赞数 4
文章标签： golang rabbitmq erlang 数据结构
于 2023-08-19 15:35:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pillow_Monkey/article/details/132380524
版权

RabbitMQ延迟队列

通过查询相关资料，现在通过 RabbitMQ 实现延迟队列的方式有两种：

RabbitMQ死信实现

通过死信实现延迟队列，RabbitMQ 有死信队列，我们要先理解两个概念

概念

  • TTL：Time To Live 存活时间，当消息没有配置消费者，消息就一直停留在队列中，停留时间超过存活时间后，消息就会被自动移动到死信交换机
  • DLX：Dead Letter Exchanges 死信交换机，死信交换机会绑定在其他队列上，当这个队列的消息变成死信消息后，死信消息就会发送到死信交换机上

通过死信实现延迟队列的原理

原理

绑定了死信交换机的队列内的消息满足成为死信的条件，被推送到死信交换机上后，被路由到死信队列，然后由消费者从死信队列中消费

满足成为死信的条件：

  • 消息被拒绝basic.reject/basic.nack&&requeue=false
  • 消息的过期时间到了TTL
  • 队列达到最大长度

利用死信实现延迟队列就要为需要延迟处理的消息设置 TTL 存活时间，且一直不进行消费，让其在经过一段时间过期后称为死信，经由死信交换机路由到死信队列后被消费者消费。

设置 TTL 存活时间的方式：

  • 对消息本身设置 TTL 存活时间，每条消息的存活时间都可以不一样
  • 对绑定死信交换机的队列设置存活时间，每条传递到此队列的消息过期时间都相同

使用流程

image-20230818112405235

  1. 为生产者发送的消息配置 TTL，使其成为延迟消息
  2. 绑定普通队列到死信交换机且让消息仅通过 TTL 到期的形式成为死信发送到死信交换机，路由到死信队列
  3. 消费者消费死信队列中的延迟消息

实现

生产者

建立链接与通道——将消息发送到延迟队列

package main

import (
	"github.com/streadway/amqp"
	"log"
	"os"
	"strings"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Fatalf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	body := bodyFrom(os.Args)
	// 将消息发送到延时队列上
	err = ch.Publish(
		"logs",           // exchange 这里为空则不选择 exchange
		"test_delay", // routing key
		false,        // mandatory
		false,        // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
			Expiration:  "5000", // 设置五秒的过期时间
		})
	failOnError(err, "Failed to publish a message")

	log.Printf(" [x] Sent %s", body)
}

func bodyFrom(args []string) string {
	var s string
	if (len(args) < 2) || os.Args[1] == "" {
		s = "hello"
	} else {
		s = strings.Join(args[1:], " ")
	}
	return s
}
消费者

建立连接通道——声明普通交换机——（声明普通队列）——声明延迟队列——绑定普通队列和交换机——监听延迟队列——进行消费

package main

import (
	"log"
	"github.com/streadway/amqp"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Fatalf("%s: %s", msg, err)
	}
}

func main() {
	// 建立链接
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	// 声明一个主要使用的 exchange
	err = ch.ExchangeDeclare(
		"logs",   // name
		"fanout", // type
		true,     // durable
		false,    // auto-deleted
		false,    // internal
		false,    // no-wait
		nil,      // arguments
	)
	failOnError(err, "Failed to declare an exchange")

	// 声明一个常规的队列, 其实这个也没必要声明,因为 exchange 会默认绑定一个队列
	queue, err := ch.QueueDeclare(
		"test_logs", // name
		false,       // durable
		false,       // delete when unused
		true,        // exclusive
		false,       // no-wait
		nil,         // arguments
	)
	failOnError(err, "Failed to declare a queue")

	// 声明一个延时队列, ß我们的延时消息就是要发送到这里
	_, errDelay := ch.QueueDeclare(
		"test_delay", // name
		false,        // durable
		false,        // delete when unused
		true,         // exclusive
		false,        // no-wait
		amqp.Table{
			// 当消息过期时把消息发送到 logs 这个 exchange
			"x-dead-letter-exchange": "logs",
		}, // arguments
	)
	failOnError(errDelay, "Failed to declare a delay_queue")

	err = ch.QueueBind(
		queue.Name, // queue name, 这里指的是 test_logs
		"",         // routing key
		"logs",     // exchange
		false,
		nil)
	failOnError(err, "Failed to bind a queue")

	// 这里监听的是 test_logs
	msgs, err := ch.Consume(
		queue.Name, // queue name, 这里指的是 test_logs
		"",         // consumer
		true,       // auto-ack
		false,      // exclusive
		false,      // no-local
		false,      // no-wait
		nil,        // args
	)
	failOnError(err, "Failed to register a consumer")

	forever := make(chan bool)

	go func() {
		for d := range msgs {
			log.Printf(" [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}

生产者将消息设定好 TTL 发送到延迟队列前，会先由主交换机发送到默认的普通队列里存活设定好的时间，时间到后由死信交换机路由到死信队列，消费者只需对死信队列进行监听，取出消息消费即可。

缺陷

普通队列里的消息是有顺序的，后入的消息必须等待先入的消息出队才可以，即使后入消息存活时间要比先入的消息长……

例如：

terminal-consumer

pillow@Mac-Pro delayed3 % go run consumer.go 
2023/08/18 16:36:47  [*] Waiting for logs. To exit press CTRL+C

terminal-15000

pillow@Mac-Pro delayed3 % go run productor.go "这是一条存活时间为 15s 的消息"
2023/08/18 16:39:00  [x] Sent 这是一条存活时间为 15s 的信息

terminal-5000

pillow@Mac-Pro delayed3 % go run productor.go "这是一条存活时间为 5s 的消息"
2023/08/18 16:39:46  [x] Sent 这是一条存活时间为 5s 的信息

我们在运行消费者之后，先发送一个存活时间为 15s 的消息，随后立刻发送一个存活时间为 5s 的消息，按照功能来讲，5s 消息应该先成为死信然后被消费，随后是 15s 消息，但实际是 15s 后，15s 消息和 5s 消息几乎同时一前一后同时被消费。

RabbitMQ 队列内部维护的数据结构为队列，先入先出，后入后出，实际上按照我们的功能来讲应当维护一个以消息 TTL 大小为依据的小顶堆或是功能类似的一个更好的数据结构。

rabbitmq_delayed_message_exchange 插件实现

插件安装

插件下载地址：rabbitmq-delayed-message-exchange

下载时要提前查看自己的 RabbitMQ 的版本，下载对应版本的插件，否则可能会报错

image-20230819145904154

将下载好的的插件包放在 RabbitMQ 安装主目录的 plugins 文件夹下。

然后执行rabbitmq-plugins enable rabbitmq_delayed_message_exchange

然后进入RabbitMQ:management在Add a New exchange选择type时能够看到x-delayed-message交换机代表插件安装成功。

image-20230819151856151

Docker 安装的 RabbitMQ 也是在容器根目录找到plugins文件夹将插件放进去执行启动插件命令即可。

image-20230819152026513

插件使用

生产者的实现很简单，只需要在消息的header中加入"x-delay"字段并用其值表示消息的 TTL，最后将其发送到延迟队列即可。

生产者
package main

import (
	"github.com/streadway/amqp"
	"log"
	"time"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Fatalf("%s: %s", msg, err)
	}
}

func main() {
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	var (
		exchange   = "x-delayed-message"
		queue      = "delay_queue"
		routingKey = "log_delay"
		body       string
	)
	// 申请交换机
	err = ch.ExchangeDeclare(exchange, exchange, true, false, false, false, amqp.Table{
		"x-delayed-type": "direct",
	})
	if err != nil {
		failOnError(err, "交换机申请失败！")
		return
	}
	if err = ch.QueueBind(queue, routingKey, exchange, false, nil); err != nil {
		failOnError(err, "绑定交换机失败！")
		return
	}

	body = "==========10000=================" + time.Now().Local().Format("2006-01-02 15:04:05")
	// 将消息发送到延时队列上
	err = ch.Publish(
		exchange,   // exchange 这里为空则不选择 exchange
		routingKey, // routing key
		false,      // mandatory
		false,      // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
			Headers: map[string]interface{}{
				"x-delay": "10000", // 消息从交换机过期时间,毫秒（x-dead-message插件提供）
			},
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s", body)

	body = "==========20000=================" + time.Now().Local().Format("2006-01-02 15:04:05")
	// 将消息发送到延时队列上
	err = ch.Publish(
		exchange,   // exchange 这里为空则不选择 exchange
		routingKey, // routing key
		false,      // mandatory
		false,      // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
			Headers: map[string]interface{}{
				"x-delay": "20000", // 消息从交换机过期时间,毫秒（x-dead-message插件提供）
			},
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s", body)

	body = "==========5000=================" + time.Now().Local().Format("2006-01-02 15:04:05")
	// 将消息发送到延时队列上
	err = ch.Publish(
		exchange,   // exchange 这里为空则不选择 exchange
		routingKey, // routing key
		false,      // mandatory
		false,      // immediate
		amqp.Publishing{
			ContentType: "text/plain",
			Body:        []byte(body),
			Headers: map[string]interface{}{
				"x-delay": "5000", // 消息从交换机过期时间,毫秒（x-dead-message插件提供）
			},
		})
	failOnError(err, "Failed to publish a message")
	log.Printf(" [x] Sent %s", body)
}
消费者

对应生产者，消费者应该声明正确的交换机类型和对应的队列即可

package main

import (
	"github.com/streadway/amqp"
	"log"
)

func failOnError(err error, msg string) {
	if err != nil {
		log.Fatalf("%s: %s", msg, err)
	}
}

func main() {
	// 建立链接
	conn, err := amqp.Dial("amqp://guest:guest@localhost:5672/")
	failOnError(err, "Failed to connect to RabbitMQ")
	defer conn.Close()

	ch, err := conn.Channel()
	failOnError(err, "Failed to open a channel")
	defer ch.Close()

	var (
		exchange   = "x-delayed-message"
		queue      = "delay_queue"
		routingKey = "log_delay"
	)

	// 申请交换机
	err = ch.ExchangeDeclare(
		exchange, // name
		exchange, // type
		true,     // durable
		false,    // auto-deleted
		false,    // internal
		false,    // no-wait
		amqp.Table{ // arguments
			"x-delayed-type": "direct",
		})
	if err != nil {
		failOnError(err, "交换机申请失败！")
		return
	}

	// 声明一个常规的队列, 其实这个也没必要声明,因为 exchange 会默认绑定一个队列
	q, err := ch.QueueDeclare(
		queue, // name
		true,  // durable
		true,  // delete when unused
		false, // exclusive
		false, // no-wait
		nil,   // arguments
	)
	failOnError(err, "Failed to declare a queue")

	err = ch.QueueBind(
		q.Name,     // queue name
		routingKey, // routing key
		exchange,   // exchange
		false,
		nil)
	failOnError(err, "Failed to bind a queue")

	// 这里监听的是 test_logs
	msgs, err := ch.Consume(
		q.Name, // queue name
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	failOnError(err, "Failed to register a consumer")

	forever := make(chan bool)

	go func() {
		for d := range msgs {
			log.Printf("接收数据 [x] %s", d.Body)
		}
	}()

	log.Printf(" [*] Waiting for logs. To exit press CTRL+C")
	<-forever
}
测试

producer

pillow@Mac-Pro delayed4 % go run producer.go 
2023/08/19 11:14:27  [x] Sent ==========10000=================2023-08-19 11:14:27
2023/08/19 11:14:27  [x] Sent ==========20000=================2023-08-19 11:14:27
2023/08/19 11:14:27  [x] Sent ==========5000=================2023-08-19 11:14:27

consumer

2023/08/19 11:14:32 接收数据 [x] ==========5000=================2023-08-19 11:14:27
2023/08/19 11:14:37 接收数据 [x] ==========10000=================2023-08-19 11:14:27
2023/08/19 11:14:47 接收数据 [x] ==========20000=================2023-08-19 11:14:27

引用链接

RabbitMQ-Community-Plugins

rabbitmq-delayed-message-exchange

golang 使用 rabbitmq 延迟队列

Golang 实现 RabbitMQ 的延迟队列

[golang rabbitmq实现的延时队列_golang rabbitmq 延迟队列_流年诠释一切的博客-CSDN博客](

Pi11ow
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
Kafka介绍及Go操作kafka详解
yonggeit的博客
07-19 551
每个业务系统都有日志，当系统出现问题时，需要通过日志信息来定位和解决问题。当系统机器比较少时，登陆到服务器上查看即可满足当系统机器规模巨大，登陆到机器上查看几乎不现实（分布式的系统，一个系统部署在十几台机器上）LogAgent：日志收集客户端，用来收集服务器上的日志Kafka：高吞吐量的分布式队列（Linkin开发，Apache顶级开源项目）ElasticSearch：开源的搜索引擎，提供基于HTTP RESTful的web接口Kibana：开源的ES数据分析和可视化工具。
Python 接口并发测试详解
悦分享
10-23 6924
性能测试是通过自动化测试工具模拟多种正常、峰值及异常负载条件对系统的各项性能指标进行的测试。负载测试和压力测试都属于性能测试，两者可以结合进行。通过负载测试，确定在各种工作负载下系统的性能，目标是测试当负载逐渐增加时，系统各项性能指标的变化情况。压力测试是通过确定一个系统的瓶颈或者不能接受的性能点，来获得系统能提供的最大服务级别的测试。性能测试的重点是测试在并发条件下服务或系统的瓶颈所在，从而优化相关功能，可能涉及软件及硬件的多方面改进。由此可见，性能测试对整个产品非常重要，甚至可以决定一个产品是否能长久发
Golang RabbitMQ实现的延时队列
weixin_44545838的博客
09-03 1180
之前做秒杀商城项目的时候使用到了延时队列来解决订单超时问题，本博客就总结一下Golang是如何利用RabbitMQ实现的延时队列的。
golang rabbitmq实现的延时队列
John_lidong的博客
04-28 2762
golang 采用RabbitMQ官方延迟插件实现延时队列 x-delayed-message
golang实现延时队列
热门推荐
liyunlonghere
02-18 3万+
github源码地址：https://github.com/hackssssss/delay_queue 参考了有赞延时队列的设计思路，自己写了一个延时队列，基本原理是利用redis的list实现队列，利用redis的zset实现按照时间排序功能。 大体流程如下图所示： 流程解读： 1. 调用方调用Push接口，将data、ttr（time to return）、notify_url传...
golang 延时队列
高精尖发展
03-16 525
package utils import ( "sync" "time" "git-pd.megvii-inc.com/slg-service/wesmock/components" "github.com/emirpasic/gods/lists/arraylist" ) type QueueData struct { Data interface{} CreateAt int64 } type Queue struct { mux sync.R.
golang实现延迟队列（delay queue）
最新发布
weixin_45565886的博客
02-21 1506
golang实现延迟队列（delay queue）
RabbitMQ 延迟队列 Golang
lishuangzhi的博客
04-28 1706
使用场景 订单在十分钟之内未支付则自动取消 新建店铺，如果在十天内都没有上传商品，则自动发送消息提醒 用户注册成功后，如果三天内没有登录则进行短信提醒 插件 RabbitMQ实现延迟队列需要使用插件 # 查看插件 rabbitmq-plugins list # 复制插件到容器 docker cp 插件名 容器id:/plugins # 启用插件 rabbitmq-plugins enable rabbitmq_delayed_message_exchange 消息在ttl之后才会进入队列，进入队列
理论和实践详解RabbitMQ惰性/延迟队列（lazy queues）（带测试样例及分析）
天然玩家的博客
07-30 688
（1）lazy queues：配置方式有两种，运行时通过策略和queue-mode变更，声明队列时通过x-queue-mode指定，其中，lazy表示为lazy队列，default表示非lazy队列； （2）lazy queues数据会即时存储到磁盘中，队列由default（非lazy）转换为lazy队列时，内存中的数据会交换到磁盘，此时会增加磁盘I/O； （3）默认情况下，进入队列的数据会在内存中，这有助于提高消费性能； （4）指定为lazy模式的队列，如遇到节点重启，默认会载入16,384条消息到内存。
RabbitMQ学习文档
桂秋拾貳
11-03 4166
RabbitMQ学习文档
Go-delay-queue基于Redis实现的延迟队列
08-14
延迟队列, 参考有赞延迟队列设计实现
基于golang的简单分布式延时队列服务的实现
09-17
主要介绍了基于golang的简单分布式延时队列服务的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
golang实现redis的延时消息队列功能示例
09-09
主要介绍了golang实现redis的延时消息队列功能，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
go-queue:Golang的优先级和延迟队列
03-04
排队 Golang的优先级和延迟队列
尹成学院区块链 Go 学习大纲-取得大纲试看视频联系微信yinchengak48
尹成的技术博客
08-21 4730
所处阶段 主讲内容 技术要点 学习目标 第一阶段Go语言开发入门实战 1.Go语言介绍及开发环境搭建 1.Go语言是什么 2.Go语言优势 3.Go语言适合来做什么 4.Go语言安装和设置 5.标准命令概述 6.第一个Go语言程序 课程设计理念： 夯实基础，Go语言作为...
RabbitMQ实现延时队列（死信队列）
07-27 287
基于队列和基于消息的TTL TTL是time to live 的简称，顾名思义指的是消息的存活时间。rabbitMq可以从两种维度设置消息过期时间，分别是队列和消息本身。 队列消息过期时间-Per-Queue Message TTL： 通过设置队列的x-message-ttl参数来设置指定队列上消息的存活时间，其值是一个非负整数，单位为微秒。不同队列的过期时间互相之间没有影响，即使是对于同一条消息...
rabbitmq接口异常函数方法_分布式系统消息中间件——RabbitMQ的使用进阶篇
weixin_29631169的博客
12-19 129
一 mandatory 参数上一篇文章中我们知道，生产者将消息发送到RabbitMQ的交换器中通过RoutingKey与BindingKey的匹配将之路由到具体的队列中以供消费者消费。那么当我们通过匹配规则找不到队列的时候，消息将何去何从呢?Rabbit给我们提供了两种方式。mandatory与备份交换器。 mandatory参数是channel.BasicPublish方...
go + redis 实现简单的延迟队列
qq_42536422的博客
02-18 1600
用到的工具以及开发语言 redis golang 背景 redis实现的简单延迟队列，这个场景在工具丰富的公司的话一般使用mq代替了，但是说公司开发选型上没有搭建这些工具，需要实现的延迟队列并不复杂和数量量不大的情况下可以考虑这个实现方式 参考文章 有赞 本文参考的线程池实现 实现思路 job pool是一个string类型的k/v形式，我们只需要把对应的key，value保存到redis中，value中包含了你想要存放的数据，这样我们在消费队列的时候可以获取到需要的信..
golang 调用RabbitMQ消息队列监控API
07-28
在 Golang 中调用 RabbitMQ 的消息队列监控 API 可以使用标准的 `net/http` 包来发送 HTTP 请求并处理响应。以下是一个简单的示例代码，用于获取 RabbitMQ 的队列信息： ```go package main import ( "encoding/...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值