RabbitMQ之任务队列【译】

在第一个教程里面，我们写了一个程序从一个有名字的队列中发送和接收消息，在这里我们将要创建一个分发耗时任务给多个worker的任务队列。


任务队列核心思想就是避免执行一个资源密集型的任务，而程序要等待其执行完毕才能进行下一步的任务。相反地我们让任务延迟执行，我们封装一个task作为消息，并把它发送至队列，在后台运行的工作进程将弹出的任务，并最终执行作业。当运行多个worker的时候，task将在他们之间共享。

准备

在前一节中我们发送一个包含“HelloWorld！”的消息，现在我们发送字符串代表一个复杂的任务，我们没有一个真实的任务，比如格式化图片大小等等，所以我们使用Thread.sleep()代表一个执行时间较长的任务，这里我们使用几个点来代表任务的复杂度，每一个点代表任务执行一秒的时间，比如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();
}

上一节中的Rece.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");
    }
  }
};
channel.basicConsume(TASK_QUEUE_NAME, true, consumer);

模拟执行时间的任务：

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

编译：

$ javac -cp rabbitmq-client.jar NewTask.java Worker.java

循环调度

使用任务队列的优点之一就是很容并行化一个work，如果我们产生了工作积压，我们可以很简单的增加worker的数量，来解决问题。

首先，让我们尝试在同一时间运行两个工人实例。他们都将在队列中得到消息，但究竟如何？让我们来看看。

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

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

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

在第三个，我们将发布新的任务。一旦你开始运行消费者就可以发布几条消息：

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.....

我们来看看它是怎样将任务非配给我们的worker的：

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.....'

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
 [x] Received 'Second message..'
 [x] Received 'Fourth message....'

默认情况下，RabbitMQ将发送每一个在序列中的消息到下一个消费者，平均而言，每一个消费者将获得相同数量的消息，发布这种消息的方式叫循环调度。

消息确认

做一个任务需要几秒钟，那么当一个消费者执行任务到一半的时候挂了怎么办？在我们的当前代码里面，一旦消息传送给我们的消费者，消息就从存储中删除了。在这种情况下，如果Kill了一个worker，我们不仅仅失去了它正在执行的消息任务，而且我们将失去所有分配给它，但是还没执行的消任务。

但是我们不想丢失任何消息，如果一个worker挂掉，我们将分配这些任务给其他的消费者。

为了确保消息不会丢失，RabbitMQ支持消息确认。一个ACK（nowledgement）从消费者发送给RabbitMQ一个消息确认当前消息已被接收和处理，RabbitMQ可自由将其删除。

如果消费者死亡（其信道被关闭，关闭连接，或TCP连接丢失），而不发送ACK，RabbitMQ知道消息并没有被接收和执行完全，将重新将它放入队列。如果同一时间存在其他在线的消费者，它将迅速重新传递消息给另一个消费者。这样，你可以肯定没有消息丢失，即使偶尔的消费者死亡。

目前没有任何消息超时，当消费者挂掉的时候，RabbitMQ将重新传递消息，即使处理一个消息需要很长很长的时间也没关系。

消息确认默认情况下开启。在前面的例子中，我们明确地通过AUTOA​​CK = true标志将它们关闭。现在是时候删除此标志，一旦我们与任务完成，将从worker发送适当的确认。

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);
    }
  }
};

使用此代码，我们可以肯定，即使你使用CTRL + C，杀死一个worker，什么都不会丢失。worker死亡后不久，所有未确认的消息会被重新传递。

被遗忘的确认

忘记baseACK是一个常见的错误，这是个简单的错误，但是后果是很严重的。当你的客户端退出的时候（可能看起来就像是随机交还）消息将被重新传递，但RabbitMQ会消耗的越来越多的内存，它将无法释放任何unacked的消息。

为了调试这种错误，你可以使用rabbitmqctl打印messages_unacknowledged字段。

$ sudo rabbitmqctl list_queues name messages_ready messages_unacknowledged

Listing queues ...

hello 0 0

...done.

消息持久化

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

当RabbitMQ的退出或崩溃时，除非你告诉它不要忘记的队列和消息。两件事情都需要确保，消息才不会丢失：我们需要将队列和消息持久化。

首先，我们需要确保的RabbitMQ永远不会失去我们的队列。为了做到这一点，我们需要把它声明为持久：

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

虽然以上的代码本身是对的，但是它不会对我们的目前设置起作用。这是因为我们已经定义了一个名为hello的不持久的队列，RabbitMQ不允许你使用不同的参数重新定义现有队列，并会返回一个错误。但是有一个快速的解决

办法 - 让我们与声明不同名称的队列，例如task_queue：

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

queueDeclare变化需要被施加到生产者和消费者代码两者。

在这一点上我们确保即使RabbitMQ的重启task_queue队列也不会被丢失。现在，我们需要我们的消息标记为持久性 - 通过设置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） - 它可能只是保存到缓存，并没有真正写入磁盘。持久性的保证不强，但是对于我们简单的任务队列还是绰绰有余的。如果你需要一个更强有力的保证，那么你可以使用publisher confirms。

公平调度

你可能已经注意到，调度仍然没有完全按照我们真正想要的工作。举个例子，比如有两个消费者的情况，当奇数的消息非常重，但是偶数的消息非常轻的时候，一个消费者将被累死，而另一个却闲着。RabbitMQ却不知道，仍然在均匀的给每个消费者发送消息。

这种情况发生是因为RabbitMQ只负责分发进入到队列的消息，它不看为消费者未确认的消息的数量。它只是盲目分派每第n个消息给第n消费者。


为了杜绝那种情况，我们可以使用basicQos方法与prefetchCount = 1设置。它告诉RabbitMQ不要把多个消息在同一时间给一个消费者。或者，换句话说，只有消费者处理并且确认前一个消息之后才会给它分配下一个消息，相反，消息将被非配给下一个不处于忙碌的消费者。

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

注意队列大小

如果所有的worker都在忙，你的队列也填满了。您将要留意的是，也许添加更多的worker，或者有一些其他的策略。

代码整合

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

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);
        }
      }
    };
    channel.basicConsume(TASK_QUEUE_NAME, false, consumer);
  }

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

原文地址：RabbitMQ之Work Queues

代码地址：https://github.com/aheizi/hi-mq

相关：

1.RabbitMQ之HelloWorld

2.RabbitMQ之任务队列

3.RabbitMQ之发布订阅

4.RabbitMQ之路由(Routing)

5.RabbitMQ之主题(Topic)

6.RabbitMQ之远程过程调用(RPC)