python系列之 RabbitMQ - work queues

本节我们创建一个工作队列( work queue )用来在多个workers之间分发消息

工作队列(又名：任务队列)的主要思想是避免在资源密集型的任务处理中不得不等待它的完成，相反，我们安排这个任务稍后完成。我们把这任务作为一个消息封装起来并发送到一个队列中，一个后台工作进程将这个任务取出并最终执行这个任务，当你运行多个任务时，多个消费者将共享这些任务。

这个概念在网页应用中对于在HTTP短连接请求中处理复杂任务时尤其有用。

预备

前面的部分我们发送了一个消息内容“hello world", 现在我们要发送复杂任务的字符串。我们没有真实世界的任务，比如重新调整一个图片大小或者渲染一个PDF文件，我们通过time.sleep()函数假装消息接收后任务非常繁忙，需要消耗一定的时间，我们通过字符串中小数点的个数来描述任务的复杂性，每个点代表“work"要耗费1秒,例如：假设一个任务描述 "Hello..." 将要耗费3秒钟。

我们修改之前的 send.py 代码，允许通过命令行来发送任意消息。这个程序将要处理任务到工作队列。我们命名为 new_task.py

import pika
import sys

message = ' '.join(sys.argv[1:]) or "Hello World"
channel.basic_publish(exchange='',
                      routing_key='worker',
                      body=message,
                      properties=pika.BasicProperties(delivery_mode = 2,)
                      )
print(" [x] Send %r " % message)

之前老的 receive.py 脚本也需要一些改变,我们对处理模块 callback 函数进行一些修改：它假装对消息中的每个小数点需要1秒时间进行处理，它将会从消息队列中pop一个消息然后执行任务，我们用 worker.py 来命名这个文件

import time

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    time.sleep(body.count(b'.'))
    print(" [x] Done")
    ch.basic_ack(delivery_tag = method.delivery_tag)

循环调度(Round-robin dispatching)

使用任务队列（tack queue）的优点是很容易的进行并行工作的能力，如果我们的工作队列产生一定的积压，我们可以创建多个worker来接收并处理消息，这样很容易扩展

首先，我们试着同时运行两个worker.py 脚本，它们都可以从消息队列中获取消息，你需要开启两个终端，运行两个 worker.py ， 当做两个Consumer： C1 和 C2

shell1$ python worker.py
 [*] Waiting for messages. To exit press CTRL+C

shell2$ python worker.py
 [*] Waiting for messages. To exit press CTRL+C

再打开一个终端，运行 new_task.py ，执行多个任务

shell3$ python new_task.py First message.
shell3$ python new_task.py Second message..
shell3$ python new_task.py Third message...
shell3$ python new_task.py Fourth message....
shell3$ python new_task.py Fifth message.....

让我们看看两个worker端接收的消息：

shell1$ python worker.py
 [*] Waiting for messages. To exit press CTRL+C
 [x] Received 'First message.'
 [x] Received 'Third message...'
 [x] Received 'Fifth message.....'

shell2$ python worker.py
 [*] Waiting for messages. To exit press CTRL+C
 [x] Received 'Second message..'
 [x] Received 'Fourth message....'

默认，RabbitMQ将循环的发送每个消息到下一个Consumer , 平均每个Consumer都会收到同样数量的消息。 这种分发消息的方式成为 循环调度（round-robin)

上述完整代码

new_task.py

import pika
import sys

connec = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connec.channel()

channel.queue_declare(queue='worker')

message = ' '.join(sys.argv[1:]) or "Hello World"
channel.basic_publish(exchange='',
                      routing_key='worker',
                      body=message,
                      properties=pika.BasicProperties(delivery_mode = 2,)
                      )
print(" [x] Send %r " % message)

worker.py

import time
import pika

connect = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
channel = connect.channel()

channel.queue_declare('worker')

def callback(ch, method, properties,body):
    print(" [x] Received %r" % body)
    time.sleep(body.count(b'.'))
    print(" [x] Done")
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,
                      queue='worker',
                      )
channel.start_consuming()

消息确认（Message acknowledgment)

执行一个任务能消耗几秒. 你可能想知道当一个consumer在执行一个艰巨任务或执行到一半是死掉了会发生什么。就我们当前的代码而言,一旦RabbitMQ 的分发完消息给 consumer后 就立即从内存中移除该消息。这样的话，如果一个worker刚启动你就结束掉，那么消息就丢失了。那么所有发送给这个 worker 的还没有处理完成的消息也将丢失。

但是我们不想丢失任何任务，如果worker死掉了，我们希望这个任务能够发送给其它的worker

为了确保一个消息不会丢失，RabbitMQ支持消息的 acknowlegements , 一个 ack(nowlegement) 是从consumer端发送一个回执去告诉RabbitMQ 消息已经接收了、处理了，RabbitMQ可以释放并删除掉了。

如果一个consumer 死掉了（channel关闭、connection关闭、或者TCP连接断开了）而没有发送ack，RabbitMQ 就会知道这个消息没有被完全处理并会重新发送到消息队列中，如果同时有另外一个consumer在线，将会很快转发到另外一个consumer中。 那样的话你就能确保虽然worker死掉，但消息不会丢失。

这个是没有超时的，当消费方（consumer）死掉后RabbitMQ会重新转发消息，即使处理这个消息需要很长很长时间也没有问题

消息的 acknowlegments 默认是打开的，在前面的例子中关闭了： no_ack = True . 现在删除这个标识 然后 发送一个 acknowledgment。

def callback(ch, method, properties, body):
    print " [x] Received %r" % (body,)
    time.sleep( body.count('.') )
    print " [x] Done"
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_consume(callback,
                      queue='hello')

使用这个代码我们能确保即使在程序运行中使用CTRL+C结束worker进程也不会有消息丢失。之后当worker死掉之后所有未确认的消息将会重新进行转发。

忘了 acknowlegement
 忘记设置basic_ack是一个经常犯也很容易犯的错误，但后果是很严重的。当客户端退出后消息将会重新转发，但RabbitMQ会因为不能释放那些没有回复的消息而消耗越来越多的内存
为了调试(debug)这种类型的错误，你可以使用 rabbitmqctl 打印 message_unacknowledged 字段：
$ sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged
Listing queues ...
hello    0       0
...done

消息持久化（Message durability)

我们已经学习了即使客户端死掉了任务也不会丢失。但是如果RabbitMQ服务停止了的话，我们的任务还是会丢失。

当RabbitMQ退出或宕掉的话将会丢失queues和消息信息，除非你进行设置告诉服务器队列不能丢失。要确保消息不会丢失需要做两件事： 我们需要将队列和消息标记为 durable

首先：

我们需要确保RabbitMQ 永远不会丢失队列，为了确保这个，我们需要定义队列为durable：

channel.queue_declare(queue='hello', durable=True

尽管此命令本身定义是正确的，但我们设置后还是不会工作。因为我们已经定义了个名为 hello ，但不是durable属性的队列。RabbitMQ不允许你重新定义一个已经存在、但属性不同的queue。RabbitMQ 将会给定义这个属性的程序返回一个错误。但这里有一个快速的解决方法：让我们定义个不同名称的队列，比如 task_queue:

channel.queue_declare(queue='task_queue', durable=True)

这个 queue_declare 需要在 生产者（producer） 和消费方（consumer) 代码中都进行设置。

基于这一点, 我们能够确保 task_queue 队列即使RabbitMQ重启也不会丢失

现在我们需要标记我们的消息为持久化的 - 通过设置 delivery_mode 属性为 2

channel.basic_publish(exchange='',
                      routing_key="task_queue",
                      body=message,
                      properties=pika.BasicProperties(
                         delivery_mode = 2, # make message persistent
                      ))

消息持久化的注意点

标记消息为持久化的并不能完全保证消息不会丢失，尽管告诉RabbitMQ保存消息到磁盘，当RabbitMQ接收到消息还没有保存的时候仍然有一个短暂的时间窗口. RabbitMQ不会对每个消息都执行同步fsync(2) --- 可能只是保存到缓存cache还没有写入到磁盘中，这个持久化保证不是很强，但这比我们简单的任务queue要好很多，如果你想很强的保证你可以使用 publisher confirms

公平调度（Fair dispatch）

你可能已经注意到分发仍然不能完全符合我们想要进行的工作。比如有两个worker的一种情况，当所有基数的消息比较重要，偶数的消息相对不重要，一个worker相对处理比较繁忙而另一个几乎不怎么工作。但是对于RabbitMQ而言，它对此一无所知并仍然均匀的分发消息。

发生这样的情况是由于RabbitMQ只是当消息来是进行分发，它并不考虑消费方（consuer）回复的ack消息，它只是一味地分发每个消息到各个消费方

为了解决这个问题我们可以使用 basic.qos 方法使用 prefetch_count = 1 设置， 这样告诉RabbitMQ不要同时将多条消息分发到一个worker， 换句话说，在一个worker未处理完之前的消息之前不要分发新的消息给它。 换言之，会将这个消息分发给另一个不是很忙的worker进行处理。

channel.basic_qos(prefetch_count=1)

代码汇总

new_task.py 脚本的全部代码为：

import pika
import sys

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue', durable=True) # 设置队列为持久化的队列

message = ' '.join(sys.argv[1:]) or "Hello World!"
channel.basic_publish(exchange='',
                      routing_key='task_queue',
                      body=message,
                      properties=pika.BasicProperties(
                         delivery_mode = 2, # 设置消息为持久化的
                      ))
print(" [x] Sent %r" % message)
connection.close()

new_task.py 脚本

#!/usr/bin/env python
import pika
import time

connection = pika.BlockingConnection(pika.ConnectionParameters(
        host='localhost'))
channel = connection.channel()

channel.queue_declare(queue='task_queue', durable=True)  # 设置队列持久化
print(' [*] Waiting for messages. To exit press CTRL+C')

def callback(ch, method, properties, body):
    print(" [x] Received %r" % body)
    time.sleep(body.count(b'.'))
    print(" [x] Done")
    ch.basic_ack(delivery_tag = method.delivery_tag)

channel.basic_qos(prefetch_count=1)   # 消息未处理完前不要发送信息的消息
channel.basic_consume(callback,
                      queue='task_queue')

channel.start_consuming()

本文来自：http://www.rabbitmq.com/tutorials/tutorial-two-python.html