RabbitMQ 教程2 工作队列

Rabbit MQ Work Queues

Work Queues(工作队列)

在第一个教程中，我们编写了从指定队列发送和接收消息的程序。在这一项中，我们将创建一个工作队列，用于在多个工作者之间分配耗时的任务。

工作队列的主要思想(即:任务队列)是为了避免立即执行资源密集型任务，并且必须等待它完成。相反，我们将任务安排在稍后完成。我们将任务封装为消息并将其发送到队列中。在后台运行的一个工人进程将会弹出任务并最终执行该任务。当你管理许多员工时，任务就会在他们之间共享。

这个概念在web应用程序中尤其有用，因为在短HTTP请求窗口中不可能处理复杂的任务。

准备

在本教程的前一部分，我们发送了一个包含“Hello World！”的消息。现在，我们将发送支持复杂任务的字符串。我们没有一个真实的任务，比如要缩放的图像或者pdf文件，所以让我们假装我们很忙——通过使用thread.sleep()函数来假装它。我们将把消息字符串里点的数量作为它的复杂度;每一个点都会有一秒钟的“工作”。例如，一个由“Hello… ”所描述的虚假任务。需要三秒钟。

我们将稍微修改一下发送。前一个示例中的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程序还需要进行一些更改:它需要为消息体中的每个点假做一秒钟的工作。它将处理传递的消息并执行任务，因此我们将其命名为Worker.java:

final Consumer consumer = new DefaultConsumer(channel) {
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    String message = new String(body, "UTF-8");

    System.out.println(" [x] Received '" + message + "'");
    try {
      doWork(message);
    } finally {
      System.out.println(" [x] Done");
    }
  }
};
boolean autoAck = true; // acknowledgment is covered below
channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);

模拟执行时间的假任务:

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

将它们编译成第1部分(使用工作目录中的jar文件和环境变量CP):

javac -cp $CP NewTask.java Worker.java

循环调度

使用任务队列的一个优点是能够轻松地并行工作。如果我们正在积累一份积压的工作，我们可以增加更多的工人，这样就可以很容易地扩大规模。

首先，让我们尝试同时运行两个Worker实例。它们都会从队列中获取消息，但具体如何?让我们来看看。

你需要打开三个控制台。两个将运行这个Worker程序。这些控制台将是我们的两个消费者-C1和C2。

# shell 1
java -cp $CP Worker
# => [*] Waiting for messages. To exit press CTRL+C

# shell 2
java -cp $CP Worker
# => [*] Waiting for messages. To exit press CTRL+C

在第三个方面，我们将发布新的任务。一旦你启动了消费者，你就可以发布一些信息:

# shell 3
java -cp $CP NewTask
# => First message.
java -cp $CP NewTask
# => Second message..
java -cp $CP NewTask
# => Third message...
java -cp $CP NewTask
# => Fourth message....
java -cp $CP NewTask
# => Fifth message.....

让我们看看给我们的员工带来了什么:

java -cp $CP Worker
# => [*] Waiting for messages. To exit press CTRL+C
# => [x] Received 'First message.'
# => [x] Received 'Third message...'
# => [x] Received 'Fifth message.....'

java -cp $CP Worker
# => [*] Waiting for messages. To exit press CTRL+C
# => [x] Received 'Second message..'
# => [x] Received 'Fourth message....'

默认情况下，RabbitMQ将按顺序将每个消息发送给下一个消费者。平均每个消费者将得到相同数量的消息。这种分发消息的方式称为循环。试着和三个或更多的工人一起试一试。

消息确认

完成一项任务可能需要几秒钟。你可能会想，如果一个消费者开始一项长时间的任务，并且只完成了一部分，那么会发生什么。在我们当前的代码中，一旦RabbitMQ向客户发送一条消息，它立即将其标记为删除。在这种情况下，如果您杀死了一个工人，我们将丢失它正在处理的消息。我们还将丢失发送给这个特定工作者的所有消息，但是还没有处理。

但我们不想失去任何任务。如果一个工人死了，我们希望这个任务被交付给另一个工人。

为了确保消息不会丢失，RabbitMQ支持消息确认。一个ack(nowledgement)由使用者返回，告诉RabbitMQ，已经接收到一个特定的消息，并且RabbitMQ可以自由地删除它。

如果一个消费者死亡(它的通道是关闭的，连接是关闭的，或者是TCP连接丢失)，而没有发送ack，那么RabbitMQ将会理解一条消息没有被完全处理，并将重新队列。如果在同一时间线上有其他消费者，那么它将很快地把它重新交付给另一个消费者。这样你就可以确保没有信息丢失，即使工人偶尔会死亡。

没有任何消息超时;RabbitMQ将在用户死亡时重新传递消息。即使处理消息需要很长时间，这也很好。

缺省情况下，手动消息确认将被打开。在前面的例子中，我们通过autoAck=true标记显式地关闭了它们。是时候把这个标志设置为错误，并在完成任务后向员工发送适当的确认信息。

channel.basicQos(1); // 一次只接受一个unack-ed信息的消息(请参见下面的内容)

final Consumer consumer = new DefaultConsumer(channel) {
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    String message = new String(body, "UTF-8");

    System.out.println(" [x] Received '" + message + "'");
    try {
      doWork(message);
    } finally {
      System.out.println(" [x] Done");
      channel.basicAck(envelope.getDeliveryTag(), false);
    }
  }
};
boolean autoAck = false;
channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);

使用这段代码，我们可以确定，即使在处理消息时使用ctrl+c杀死一个工人，也不会丢失任何东西。在工人死后不久，所有未被确认的消息将被重新发送。

被遗忘的ACK

错过basicAck是一个常见的错误。这是一个容易犯的错误，但后果是严重的。当您的客户机退出时，消息将被重新发送(这看起来像是随机的重新发送)，但是RabbitMQ将会消耗更多的内存，因为它将无法释放任何未被释放的消息。

为了调试这类错误，您可以使用rabbitmqctl来打印 messages_unacknowledged 字段:

sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged

在Windows上，删除sudo:

rabbitmqctl.bat list_queues name messages_ready messages_unacknowledged

消息的耐久性

我们已经学会了如何确保即使消费者死亡，任务也不会丢失。但是如果RabbitMQ服务器停止，我们的任务仍然会丢失。

当RabbitMQ退出或崩溃时，它将会忘记队列和消息，除非您告诉它不要这样做。需要有两件事来确保消息不会丢失:我们需要将队列和消息标记为持久的。

首先，我们需要确保RabbitMQ永远不会丢失我们的队列。为了实现这一目的，我们需要将其声明为持久的:

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

尽管这个命令本身是正确的，但它在我们当前的设置中是无效的。这是因为我们已经定义了一个名为hello的队列，它不是持久的。RabbitMQ不允许您重新定义具有不同参数的现有队列，并将返回任何试图执行此操作的程序的错误。但是有一个快速的解决方法——让我们声明一个有不同名称的队列，例如taskqueue:

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

该队列声明更改需要应用于生产者和消费者代码。

此时，我们确信即使RabbitMQ重新启动，任务队列队列也不会丢失。现在，我们需要通过将MessageProperties(实现BasicProperties)设置为值PERSISTENT_TEXT_PLAIN.来标记我们的消息。

import com.rabbitmq.client.MessageProperties;

channel.basicPublish("", "task_queue",
            MessageProperties.PERSISTENT_TEXT_PLAIN,
            message.getBytes());

注意消息的持久性

将消息标记为持久性并不能完全保证消息不会丢失。尽管它告诉RabbitMQ将消息保存到磁盘上，但是当RabbitMQ接受消息并没有保存它时，仍然有一个很短的时间窗口。另外，RabbitMQ不会为每条消息执行fsync(2)——它可能只是保存到缓存中，而不是真正写到磁盘上。持久性保证并不强大，但对于我们的简单任务队列来说，这已经足够了。如果你需要一个更强大的保证，那么你可以使用出版商的确认。

公平的分配

您可能已经注意到，分派仍然不能按照我们的要求工作。例如，在一个有两名员工的情况下，当所有奇怪的消息都很重，甚至消息都很轻时，一个工人就会一直忙碌，而另一个工人几乎不会做任何工作。不过，RabbitMQ对此一无所知，它仍然会将消息平均分配。

这是因为RabbitMQ在消息进入队列时仅发送一条消息。它不考虑消费者的未确认消息的数量。它只是盲目地将每个n个消息发送给第n个消费者。

为了克服这个问题，我们可以使用prefetchCount=1设置的basicQos方法。这就告诉RabbitMQ不要一次给一个工人发送多个消息。或者，换句话说，在处理和承认之前的工作时，不要向工作人员发送一条新消息。相反，它将把它分派给下一个不太忙的工人。

int prefetchCount = 1;
channel.basicQos(prefetchCount);

注意队列大小

如果所有的工人都很忙，你的队伍就可以填满了。你会想要关注这个问题，可能会增加更多的员工，或者有其他的策略。

把它放在一起

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();
  }      
  //...
}

(NewTask.java source)

And our Worker.java:

import com.rabbitmq.client.*;

import java.io.IOException;

public class Worker {
  private static final String TASK_QUEUE_NAME = "task_queue";

  public static void main(String[] argv) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    final Connection connection = factory.newConnection();
    final 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);

    final Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        String message = new String(body, "UTF-8");

        System.out.println(" [x] Received '" + message + "'");
        try {
          doWork(message);
        } finally {
          System.out.println(" [x] Done");
          channel.basicAck(envelope.getDeliveryTag(), false);
        }
      }
    };
    boolean autoAck = false;
    channel.basicConsume(TASK_QUEUE_NAME, autoAck, consumer);
  }

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

(Worker.java source)

使用消息确认和prefetchCount，您可以设置一个工作队列。即使RabbitMQ重新启动，持久性选项也可以让任务继续存在。

有关通道方法和消息属性的更多信息，您可以在网上浏览JavaDocs online.。

现在，我们可以继续学习tutorial 3 ，并学习如何向许多消费者传递相同的信息。