java消息分发机制_RabbitMQ消息队列（四） ——任务分发机制

在上一篇(RabbitMQ消息队列(四))，实现的是单个生产者向单个消费者发送消息。在本篇文章中，实现的是单个生产者向多个消费者发送的功能。如下图所示：

1、发送方

packagecom.wb.rabbitmq.demo3workQueues;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;public classNewTask {private static final String QUEUE_NAME = "hello";//消息队列名称

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

}private staticString 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]);

}returnwords.toString();

}public static void main(String[] argv) throwsjava.io.IOException {

ConnectionFactory factory= new ConnectionFactory();//创建RabbitMQ连接工厂

factory.setHost("localhost");//RabbitMQ服务器IP地址，若在本地安装，则为localhost

Connection connection = factory.newConnection();//创建RabbitMQ连接

Channel channel = connection.createChannel();//创建RabbitMQ连接channel

channel.queueDeclare(QUEUE_NAME,false, false, false, null);

String message= getMessage(argv);//传送的消息

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

System.out.println(" [x] Sent '" + message + "'");//调用完毕，别忘记关闭channel、connection

channel.close();

connection.close();

}

}

2、接收方

packagecom.wb.rabbitmq.demo3workQueues;importjava.io.IOException;importcom.rabbitmq.client.AMQP;importcom.rabbitmq.client.Channel;importcom.rabbitmq.client.Connection;importcom.rabbitmq.client.ConnectionFactory;importcom.rabbitmq.client.Consumer;importcom.rabbitmq.client.DefaultConsumer;importcom.rabbitmq.client.Envelope;public classWorker {private final static String QUEUE_NAME = "hello";//队列名称，与发送方保持一致

private static void doWork(String task) throwsInterruptedException {for (charch : task.toCharArray()) {if (ch == '.')

Thread.sleep(1000);

}

}public static void main(String[] argv) throwsjava.io.IOException, java.lang.InterruptedException {

ConnectionFactory factory= newConnectionFactory();

factory.setHost("localhost");

Connection connection=factory.newConnection();

Channel channel=connection.createChannel();

channel.queueDeclare(QUEUE_NAME,false, false, false, null);

System.out.println(" [*] Waiting for messages. To exit press CTRL+C");final Consumer consumer = newDefaultConsumer(channel) {

@Overridepublic voidhandleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties,byte[] body) throwsIOException {

String message= new String(body, "UTF-8");

System.out.println(" [x] Received '" + message + "'");try{

doWork(message);

}catch(InterruptedException e) {

e.printStackTrace();

}finally{

System.out.println(" [x] Done");

}

}

};boolean autoAck = true; //acknowledgment is covered below

channel.basicConsume(QUEUE_NAME, autoAck, consumer);

}

}

3、运行验证

在这里需要用终端运行java文件。

1、项目下，target目录下

打开目录 ../rabbitmq/target/classes/com/wb/rabbitmq/demo3workQueues

拷贝NewTask.class  Worker.class  Worker$1.class 文件到 ../rabbitmq/src/java/com/wb/rabbitmq/demo3workQueues

2、下载 amqp-client-4.0.2.jar ，拷贝到 ../rabbitmq/src/java

3、打开两个终端，执行(开启两个worker)

java -cp .:amqp-client-3.0.4.jar com.wb.rabbitmq.demo3workQueues.Worker

4、再打开一个终端，分配任务，(发送消息)

java -cp .:amqp-client-3.0.4.jar com.wb.rabbitmq.demo3workQueues.NewTask 1.......

默认情况下，RabbitMQ 会顺序的分发每个Message。当每个收到ack后，会将该Message删除，然后将下一个Message分发到下一个Consumer。这种分发方式叫做round-robin。这种分发还有问题，接着向下读吧。

4. Message acknowledgment 消息确认

每个Consumer可能需要一段时间才能处理完收到的数据。如果在这个过程中，Consumer出错了，异常退出了，而数据还没有处理完成，那么非常不幸，这段数据就丢失了。因为我们采用no-ack的方式进行确认，也就是说，每次Consumer接到数据后，而不管是否处理完成，RabbitMQ Server会立即把这个Message标记为完成，然后从queue中删除了。

如果一个Consumer异常退出了，它处理的数据能够被另外的Consumer处理，这样数据在这种情况下就不会丢失了(注意是这种情况下)。

为了保证数据不被丢失，RabbitMQ支持消息确认机制，即acknowledgments。为了保证数据能被正确处理而不仅仅是被Consumer收到，那么我们不能采用no-ack。而应该是在处理完数据后发送ack。

在处理数据后发送的ack，就是告诉RabbitMQ数据已经被接收，处理完成，RabbitMQ可以去安全的删除它了。

如果Consumer退出了但是没有发送ack，那么RabbitMQ就会把这个Message发送到下一个Consumer。这样就保证了在Consumer异常退出的情况下数据也不会丢失。

这里并没有用到超时机制。RabbitMQ仅仅通过Consumer的连接中断来确认该Message并没有被正确处理。也就是说，RabbitMQ给了Consumer足够长的时间来做数据处理。

默认情况下，消息确认是打开的(enabled)。在上篇文章中我们通过no_ack = True 关闭了ack。重新修改一下callback，以在消息处理完成后发送ack：

这样即使你通过Ctr-C中断了worker.class，那么Message也不会丢失了，它会被分发到下一个Consumer。

channel.basicQos(1); //accept only one unack-ed message at a time (see below)

final Consumer consumer = newDefaultConsumer(channel) {

@Overridepublic void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throwsIOException {

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

如果忘记了ack，那么后果很严重。当Consumer退出时，Message会重新分发。然后RabbitMQ会占用越来越多的内存，由于RabbitMQ会长时间运行，因此这个“内存泄漏”是致命的。去调试这种错误。

4. Message durability消息持久化

在上一节中我们知道了即使Consumer异常退出，Message也不会丢失。但是如果RabbitMQ Server退出呢？软件都有bug，即使RabbitMQ Server是完美毫无bug的(当然这是不可能的，是软件就有bug，没有bug的那不叫软件)，它还是有可能退出的：被其它软件影响，或者系统重启了，系统panic了。。。

为了保证在RabbitMQ退出或者crash了数据仍没有丢失，需要将queue和Message都要持久化。

queue的持久化需要在声明时指定durable=True：

boolean durable = true;

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

但是确得不到我们想要的结果，原因就是RabbitMQ Server已经维护了一个叫hello的queue，那么上述执行不会有任何的作用，也就是hello的任何属性都不会被影响。这一点在上篇文章也讨论过。

那么workaround也很简单，声明一个另外的名字的queue，比如名字定位task_queue：

boolean durable = true;

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

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

再次强调，Producer和Consumer都应该去创建这个queue，尽管只有一个地方的创建是真正起作用的：

接下来，需要持久化Message，即在Publish的时候指定一个properties，方式如下：

importcom.rabbitmq.client.MessageProperties;

channel.basicPublish("", "task_queue",

MessageProperties.PERSISTENT_TEXT_PLAIN,

message.getBytes());

关于持久化的进一步讨论：

为了数据不丢失，我们采用了：

在数据处理结束后发送ack，这样RabbitMQ Server会认为Message Deliver 成功。

持久化queue，可以防止RabbitMQ Server 重启或者crash引起的数据丢失。

持久化Message，理由同上。

但是这样能保证数据100%不丢失吗？

答案是否定的。问题就在与RabbitMQ需要时间去把这些信息存到磁盘上，这个time window虽然短，但是它的确还是有。在这个时间窗口内如果数据没有保存，数据还会丢失。还有另一个原因就是RabbitMQ并不是为每个Message都做fsync：它可能仅仅是把它保存到Cache里，还没来得及保存到物理磁盘上。

因此这个持久化还是有问题。但是对于大多数应用来说，这已经足够了。当然为了保持一致性，你可以把每次的publish放到一个transaction中。这个transaction的实现需要user defined codes。

那么商业系统会做什么呢？一种可能的方案是在系统panic时或者异常重启时或者断电时，应该给各个应用留出时间去flash cache，保证每个应用都能exit gracefully。

5. Fair dispatch 公平分发

你可能也注意到了，分发机制不是那么优雅。默认状态下，RabbitMQ将第n个Message分发给第n个Consumer。当然n是取余后的。它不管Consumer是否还有unacked Message，只是按照这个默认机制进行分发。

那么如果有个Consumer工作比较重，那么就会导致有的Consumer基本没事可做，有的Consumer却是毫无休息的机会。那么，RabbitMQ是如何处理这种问题呢？

通过 basic.qos 方法设置prefetch_count=1 。这样RabbitMQ就会使得每个Consumer在同一个时间点最多处理一个Message。换句话说，在接收到该Consumer的ack前，他它不会将新的Message分发给它。 设置方法如下：

int prefetchCount = 1;

channel.basicQos(prefetchCount);

注意，这种方法可能会导致queue满。当然，这种情况下你可能需要添加更多的Consumer，或者创建更多的virtualHost来细化你的设计。