RabbitMQ之work queue

最新推荐文章于 2024-12-13 20:41:03 发布

原创最新推荐文章于 2024-12-13 20:41:03 发布 · 603 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#rabbitmq #golang

消息队列专栏收录该内容

8 篇文章

订阅专栏

本文介绍了使用RabbitMQ实现工作队列的工作原理，通过将资源密集型任务延迟执行，避免阻塞Web应用。文中展示了如何创建生产者发送消息到队列，以及启动消费者（worker）从队列中读取并处理消息。同时，讨论了消息确认、持久化、公平分发等关键特性，强调了手动确认和预取值在确保消息处理完整性和负载均衡中的作用。

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

work queue

主要思想: 避免立即执行资源密集型任务，而不得不等待它完成。安排任务在之后执行，我们将任务封装为消息并放送到队列。而后台的工作进程从消息队列中读取消息并执行任务。当有多个工作线程时，这些线程将一起处理这些任务。

这个概念在 Web 应用程序中特别有用，在这些应用程序中，无法在短暂的 HTTP 请求窗口中处理复杂的任务。

work queue适合在集群环境中做异步处理，能最大程度发挥每一台服务器的性能

生产者代码, 简单的往队列发送20条消息

package main

import (
	"fmt"
	"github.com/streadway/amqp"
	"log"
	"rabbit/utils"
)

func main() {
	ch, _ := utils.GetRabbitMQChannel()

	q, _ := ch.QueueDeclare(
		"hello", // name
		false,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	for i := 0; i < 20; i++ {
		msg := fmt.Sprintf("%d号消息", i+1)
		_ = ch.Publish(
			"",     // exchange
			q.Name, // routing key
			false,  // mandatory
			false,
			amqp.Publishing{
				DeliveryMode: amqp.Persistent,
				ContentType:  "text/plain",
				Body:         []byte(msg),
			})
		log.Printf(" Sent %s", msg)
	}
}

消费者代码, 开启三个goroutine作为worker从队列里读数据

package main

import (
	"github.com/streadway/amqp"
	"log"
	"rabbit/utils"
	"sync"
)

func main() {
	ch, _ := utils.GetRabbitMQChannel()
	q, _ := ch.QueueDeclare(
		"hello", // name
		false,   // durable
		false,   // delete when unused
		false,   // exclusive
		false,   // no-wait
		nil,     // arguments
	)
	var wg sync.WaitGroup
	wg.Add(3)
	for i := 0; i < 3; i++ {
		go work(i+1, q, ch, &wg)
	}
	wg.Wait()
}

func work(id int, q amqp.Queue, ch *amqp.Channel, wg *sync.WaitGroup) {
	defer wg.Done()
	msgs, _ := ch.Consume(
		q.Name, // queue
		"",     // consumer
		true,   // auto-ack
		false,  // exclusive
		false,  // no-local
		false,  // no-wait
		nil,    // args
	)
	forever := make(chan bool)
	go func() {
		for d := range msgs {
			log.Printf("[%d号worker]Received a message: %s", id, d.Body)
		}
	}()
	<-forever
}

运行结果

F:\go_workspace\mq\rabbit\work-queues\workers>go run worker.go
2022/04/18 22:10:12 [3号worker]Received a message: 1号消息
2022/04/18 22:10:12 [1号worker]Received a message: 2号消息
2022/04/18 22:10:12 [1号worker]Received a message: 5号消息
2022/04/18 22:10:12 [3号worker]Received a message: 4号消息
2022/04/18 22:10:12 [3号worker]Received a message: 7号消息
2022/04/18 22:10:12 [3号worker]Received a message: 10号消息
2022/04/18 22:10:12 [2号worker]Received a message: 3号消息
2022/04/18 22:10:12 [2号worker]Received a message: 6号消息
2022/04/18 22:10:12 [2号worker]Received a message: 9号消息
2022/04/18 22:10:12 [1号worker]Received a message: 8号消息
2022/04/18 22:10:12 [1号worker]Received a message: 11号消息
2022/04/18 22:10:12 [2号worker]Received a message: 12号消息
2022/04/18 22:10:12 [2号worker]Received a message: 15号消息
2022/04/18 22:10:12 [3号worker]Received a message: 13号消息
2022/04/18 22:10:12 [1号worker]Received a message: 14号消息
2022/04/18 22:10:12 [1号worker]Received a message: 17号消息
2022/04/18 22:10:12 [3号worker]Received a message: 16号消息
2022/04/18 22:10:12 [3号worker]Received a message: 19号消息
2022/04/18 22:10:12 [2号worker]Received a message: 18号消息
2022/04/18 22:10:12 [1号worker]Received a message: 20号消息

仔细观察发现，

消息号n%3 等于1的都是3号worker处理的；

消息号n%3 等于2的都是1号worker处理的；

消息号n%3 等于0的都是2号worker处理的。

就是轮询机制

消息确认[Message acknowledgment]

因为RabbitMQ一旦向消费者传递一条消息，便立即将消息标记为删除。消费者完成一个任务可能需要一段时间，如果其中一个消费者处理一个任务只完成了部分突然挂掉，这样会导致我们丢失正在处理的消息，以及后续发送给该消费者的消息。

消息应答的方法:

自动确认

msgs, err := ch.Consume(
  q.Name, // queue
  "",     // consumer
  false,  // auto-ack
  false,  // exclusive
  false,  // no-local
  false,  // no-wait
  nil,    // args
)

手动确认

go func() {
    for d := range msgs {
        log.Printf("Received a message: %s", d.Body)
        d.Ack(false) //不批量确认
    }
}()

推荐使用手动确认，并其不批量确认

消息自动重新入队

如果消费者由于某些原因失去连接(其通道已关闭，连接已关闭或TCP连接丢失), 导致消息未发送ACK确认，RabbitMQ将了解到消息未完全处理，并将其重新加入到队列中，等待其他消费者来处理。

消息持久化[message durability]

首先，我们需要确保队列能够在 RabbitMQ 节点重启后继续存在。

生产者和消费者的队列声明都需要设置durable: true

q, err := ch.QueueDeclare(
  "hello",      // name
  true,         // durable
  false,        // delete when unused
  false,        // exclusive
  false,        // no-wait
  nil,          // arguments
)

其次, 我们需要将我们的消息标记为持久 - 通过使用 amqp.Persistent 选项 amqp.Publishing 采取。

err = ch.Publish(
  "",           // exchange
  q.Name,       // routing key
  false,        // mandatory
  false,
  amqp.Publishing {
    DeliveryMode: amqp.Persistent,
    ContentType:  "text/plain",
    Body:         []byte(body),
})

注意：rabbitmq中的队列是不允许同名但属性不同的

公平分发[fair dispatch]

轮询分发并不算是公平的。例如在有两个worker的情况下，当所有奇数消息很重而偶数消息都很轻时，一个worker会一直很忙，另一个worker几乎不会做任何工作。

消费者添加代码

err = ch.Qos(
  1,     // prefetch count
  0,     // prefetch size
  false, // global
)
failOnError(err, "Failed to set QoS")

prefechCount = 1表示：在处理并确认前一个消息之前，不要向worker发送新消息。相反，它将把它分派给下一个不忙的worker。

发布确认

单个确认发布
批量确认
异步批量确认