RabbitMQ的work queue(1)

http://www.rabbitmq.com/tutorials/tutorial-two-java.html

在第一个教程中，我们通过一个命名队列来发送消息和接受消息。在这一节，我们将创建一个工作队列，在多个工作者之间，分发比较耗时的任务

工作队列主要是为了避免资源密集型任务的立即执行，然后一直等待它执行结束。相反，我们可以安排好任务，然后在执行。我们可以将一个任务封装成一个消息，发送到队列中。由工作者在后台取出任务然后执行。当有多个工作者时，他们共同处理这些任务。

在web应用中，当一次http请求需要处理复杂的任务时，工作队列将会变得非常有用

1：Preparation

在前面的教程中，我们发送一条消息“Hello World！”，现在我们会发送一条字符串，来模拟一个复杂的任务。我们没有像图片的大小调整或者pdf文件的渲染这类很耗时的任务，所以我们通过Thread.sleep()来模拟耗时任务。我们通过字符串中的点来模拟复杂度，每个点将代表一个耗时1秒的工作。例如：任务“Hello. . .”将耗时3秒。

我们会略微的修改前面的Send.java代码，使其可以接受控制端输入的随意的字符串。程序会将任务安排到我们的工作队列中，所以我们命名为NewTask.java

String message = getMessage(argv);

channel.basicPublish("", "hello", null, message.getBytes());

System.out.println(" [x] Sent '" + message + "'");

从客户端接受消息

private static String getMessage(String[] strings){
    if (strings.length < 1)
        return "Hello World!";
    return joinStrings(strings, " ");
}

private static String joinStrings(String[] strings, String delimiter) {
    int length = strings.length;
    if (length == 0) return "";
    StringBuilder words = new StringBuilder(strings[0]);
    for (int i = 1; i < length; i++) {
        words.append(delimiter).append(strings[i]);
    }
    return words.toString();
}

我们的Recv.java代码也需要一些变化：它需要假设字符串中得每个点，都需要耗时1秒。它会从消息队列中弹出一条消息，然后执行，所以我们叫他Work.java

while (true) {
    QueueingConsumer.Delivery delivery = consumer.nextDelivery();
    String message = new String(delivery.getBody());
    System.out.println(" [x] Received '" + message + "'");
    doWork(message);
    System.out.println(" [x] Done");
}

我们模拟执行的任务

private static void doWork(String task) throws InterruptedException {
    for (char ch: task.toCharArray()) {
        if (ch == '.') Thread.sleep(1000);
    }
}

2：Round-robin dispatching(循环调度)

使用工作队列的一个优点就是可以并行的执行。如果我们需要处理积压的工作，可以通过这种方式添加更多的工作者，并且很容易扩展

首先，同时先运行两个Worker.java代码，它们都将从消息队列获取消息。我们需要开启3个控制端窗口。两个运行Worker.java代码，它们作为消费者

shell1$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

Worker

[*] Waiting for messages. To exit press CTRL+C

shell2$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

Worker

[*] Waiting for messages. To exit press CTRL+C

第三个窗口，我们会发布任务。一旦启动了consumer消费者之后，你就可以发布一些消息：

shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

NewTask First message.

shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

NewTask Second message..

shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

NewTask Third message...

shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

NewTask Fourth message....

shell3$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

NewTask Fifth message.....

让我们看看我们的工作者接受到了那些信息：

shell1$ java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

Worker

[*] Waiting for messages. To exit press CTRL+C

[x] Received 'First message.'

[x] Received 'Third message...'

[x] Received 'Fifth message.....'

java -cp .:commons-io-1.2.jar:commons-cli-1.1.jar:rabbitmq-client.jar

Worker

[*] Waiting for messages. To exit press CTRL+C

[x] Received 'Second message..'

[x] Received 'Fourth message....'

默认情况下，RabbitMQ会以此发送消息给下一个消费者。平均下来，每个消费者都会获得相同数量的消息。这种分发消息的方式就叫做Round-robin dispatching(循环调度)。

4：Message acknowledgment(消息确认)

一个任务可能花费几秒种的之间，当一个消费者开始执行一个耗时的任务，并且只执行了任务的一部分就死亡时，你或许希望知道究竟发生了什么。通过我们目前的代码，一旦RabbitMQ向向消费者传递消息，它会立即从内存中将其删除。在这种情况下，如果你杀死了一个worker，我们将会失去它正在处理的消息。我们同样会失去所有交给它，但还没来得及处理的消息。但是我们不希望丢失任何的tasks。如果一个worker死亡，我们希望该task被交给另一个worker来处理。

为了确保不丢失任何的message，RabbitMQ支持消息的确认。消费者会向RabbitMQ发送ack，来告诉RabbitMQ它已经接收，处理消息，RabbitMQ可以将其删除。

如果消费者没有发送ack就已经死亡，RabbitMQ会将其理解为消息没有被正确的处理，会将其从新发送给另一个消费者。通过这种方式，可以确保即便是worker偶然的死亡，也不会丢失任何消息。

不存在消息的超时。只有在worker的连接被关闭时，RabbitMQ才会将消息从新发送给下一个worker。即便是处理一个任务需要花费很长很长的时间，他也会正常的执行，而不会从新发送消息。

消息确认默认是开启的。在前面的例子中，我们通过autoAck=true，将其关闭。当我们执行一个task时，需要开启该功能，使worker可以发送一个正确的消息确认。

QueueingConsumer consumer = new QueueingConsumer(channel);
boolean autoAck = false;
channel.basicConsume("hello", autoAck, consumer);
while (true) {
  QueueingConsumer.Delivery delivery = consumer.nextDelivery();
  //...
  channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}

使用这样的代码，可以保证当worker正在处理一条消息时，强行将其关闭，也不会丢失任何的消息。在worker死亡后，所有未被确认的消息都将被从新发送。

5：Message durability(消息持久化)

我们已经学习了如何确保消费者死亡，任务也不会丢失。但是一旦我们的RabbitMQ服务停止，任务还是同样会丢失。

如果你不告诉RabbitMQ，当它退出或发生灾难关闭时，它会丢失队列里的消息。我们需要做两件事情来确保消息不会丢失：我们需要同时保证队列和消息时持久的。

首先：我们需要保证RabbitMQ不会丢失我们的队列。为了实现这个目的，我们需要将队列申明为永久的：

boolean durable = true;

channel.queueDeclare("hello", durable, false, false, null);

即便命令执行正常，在我们现有的程序中，它也不会起作用。那是因为我们已经存在一个非永久的队列“hello”。RabbitMQ不允许我们使用不同的参数来定义一个已经存在的队列，它会向我们返回一些错误信息。但是，通过使用不同的名字(eg：task_queue)，来定义一个新的队列，可以快速的解决这个问题。

boolean durable = true;

channel.queueDeclare("task_queue", durable, false, false, null);

queueDeclare方法申明队列的变动，需要保证同时被应用在生产者和消费者两方

通过这种方式，我们可以确保task_queue队列在RabbitMQ服务重启后也不会丢失。现在我们需要把我们的消息也标记为永久的。通过设置MessageProperties(实现了BasicProperties)的值为PERSISTENT_TEXT_PLAIN可以实现这一目的。

channel.basicPublish("","task_queue",

MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());

消息持久化注意事项

即便我们将消息标记为永久的，但这也不能完全保证消息就一定不会丢失。虽然RabbitMQ会将消息保存到硬盘上，但是在RabbitMQ接收到消息并且将其保存到硬盘上之间，仍然有一个短暂的时间片段。

6：Fair dispatch (公平调度)

可能你已经注意到了，分发工作并没有按照我们预期的方式来执行。例如：当有两个工作者时，所有的奇数任务都比较繁重，偶数任务都比较简单。这样就导致了一个工作者会一直处于忙碌状态，而另一个工作者几乎没有事情可做。RabbitMQ对于这些情况并不了解，它还会均匀的分配任务。

发生这样的原因是因为一旦有消息进入队列，RabbitMQ就会将消息进行分发。他不会去观察消费者发回的确认信息。它会盲目的将n条消息分发给n个消费者。为了杜绝这种情况，我们可以通过basicQos方法设置prefetchCount = 1。它会限制RabbitMQ在同一时间向一个工作者发送一条以上的消息。换句话说，它会等待一个工作者处理完或者接收到上一条消息的确认信息，才向它发送新的消息。否者，它会将其分发给下一个比较空闲的工作者。

int prefetchCount = 1;

channel.basicQos(prefetchCount);

注意：如果所有的工作者都处于忙碌的状态，你的队列可能会被填满，你需要时刻注意。或许你可以添加更多的工作者或者采用其他的策略。

7：Putting it all together(完整代码)

NewTask.java

import java.io.IOException;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.MessageProperties;

public class NewTask {
  private static final String TASK_QUEUE_NAME = "task_queue";
  public static void main(String[] argv)  throws java.io.IOException {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
    String message = getMessage(argv);
    channel.basicPublish( "", TASK_QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
    System.out.println(" [x] Sent '" + message + "'");

    channel.close();
    connection.close();
  }
  //...
}

Work.java

import java.io.IOException;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class Worker {
  private static final String TASK_QUEUE_NAME = "task_queue";
  public static void main(String[] argv) throws java.io.IOException, java.lang.InterruptedException {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    Connection connection = factory.newConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
    channel.basicQos(1);
    QueueingConsumer consumer = new QueueingConsumer(channel);
    channel.basicConsume(TASK_QUEUE_NAME, false, consumer);
    while (true) {
      QueueingConsumer.Delivery delivery = consumer.nextDelivery();
      String message = new String(delivery.getBody());
      System.out.println(" [x] Received '" + message + "'");
      doWork(message);
      System.out.println(" [x] Done" );
      channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
    }
  }
  //...
}