RabbitMQ的consumer预取(prefetch)行为

RabbitMQ的consumer可以在Pull模式处理消息, 也可以在push模式下处理消息.无论是pull模式还是在push模式, 都可以设置消息确认方式:自动确认(autoAck为true),或者手动确认(autoAck为false).autoAck这个参数名存在可能存在一些歧义, 当这个参数为true时, RabbitMQ服务器在发送消息到socket插口后, 就会将消息移除,consumer不会对消息进行确认.

关于消息确认方式需要注意如下细节:

• 显而易见的是, 自动确认将减少网络流量, 但是, RabbitMQ服务器无法知道消息是否投递成功, consumer是否成功的处理了投递的消息.自动确认方式的另一个影响是, 如果consumer是push模式, RabbitMQ服务器会持续的把消息投递到consumer上, 如果投递的消息数量比较大, consumer的处理能力比较慢, 这将对consumer的资源占用造成很大的压力.
• 手动确认方式时, consumer可以给RabbitMQ服务器返回一个明确的确认结果, 而且consumer可以更灵活的掌握何时进行消息的确认. consumer可以在接收到消息时就确认(如果这种情况满足设计场景的话), 也可以在消息处理完毕,向服务器返回确认消息.RabbiteMQ服务器在没有收到消息确认时,将保持对该消息的引用.因此,这种方式是一种更可靠的处理方式.

可以使用basicConsume注册push模式工作的consumer, 当使用手动确认消息的方式时, 默认处理流程是:

• RabbitMQ服务器投递一个消息到consumer, consumer处理该消息并确认, RabbitMQ接收到确认后, 移除该消息, 并继续投递下一个消息.

在consumer的实现中, 可以使用basicQos API改变这种默认的流程, 即,可以让RabbitMQ一次投递多个消息到consumer, 实现消息的预取(prefetch). 下面通过一个完整的示例说明预取的操作.

示例代码

import java.io.IOException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.GetResponse;
import com.rabbitmq.client.AMQP.BasicProperties;

public class QSQueue {
   private static final String NORMAL_EXCHANGE = "normal_exchange";   
   private static final String DEFAULT_WORKER_QUEUE = "queue_to_normal_exchange";
   private static final String NORMAL_ROUTE_KEY = "normal_route_key";
       
   private Connection connection;
   // For consumer and producer schedule.
   private final ExecutorService executorService;
   
   private static class SimpleThreadFactory implements ThreadFactory {
       private final AtomicInteger idx = new AtomicInteger(0);
               
       public Thread newThread(Runnable r) {
           return new Thread(r, "Thread#" + idx.getAndIncrement());            
       }        
   }
   
   private static class WorkerConsumer implements Runnable {
       private static final int PREFETCH_COUNTS = 2;
       private final Connection connection;
       private final boolean pushMode;
       private Channel channel;    
       
       private final DeliverCallback deliverCallback = (consumerTag, delivery) -> {            
           final String message = new String(delivery.getBody(), "UTF-8");
           final Envelope envelope = delivery.getEnvelope();
           final long deliveryTag = envelope.getDeliveryTag();
           final BasicProperties props = delivery.getProperties();
           final String msgId = props.getMessageId();
           
           System.out.println("Received msg:" + message 
                           + " delivery tag:" + deliveryTag                             
                           + " msg id:" + msgId );
           // Simulate a very time consuming work.
           try {
               Thread.sleep(1000*60*5);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           channel.basicAck(deliveryTag, false);                                
       };
       
       private void handleGettedMsg(GetResponse getResponse, boolean autoAck) throws IOException {
           final String message = new String(getResponse.getBody(), "UTF-8");
           final Envelope envelope = getResponse.getEnvelope();
           final long deliveryTag = envelope.getDeliveryTag();
           final BasicProperties props = getResponse.getProps();
           final String msgId = props.getMessageId();
           
           System.out.println("Getted msg:" + message  
                           + " delivery tag:" + deliveryTag                             
                           + " msg id:" + msgId );
           if (!autoAck) {
               channel.basicAck(deliveryTag, false);
           }            
       }
       
       public WorkerConsumer(Connection connection, boolean pushMode) {
           this.connection = connection; 
           this.pushMode = pushMode;
       }
       
       @Override
       public void run() {
           try {
               channel = connection.createChannel();
               if (pushMode) {
                   channel.basicQos(0, PREFETCH_COUNTS, false);
               }                           
               channel.exchangeDeclare(NORMAL_EXCHANGE, "direct");                
               channel.queueDeclare(DEFAULT_WORKER_QUEUE, false, false, true, null);
               channel.queueBind(DEFAULT_WORKER_QUEUE, NORMAL_EXCHANGE, NORMAL_ROUTE_KEY);
               
               // Push mode
               if (pushMode) {
                   final String tag = channel.basicConsume(DEFAULT_WORKER_QUEUE, false, deliverCallback, consumerTag -> {System.out.println("Cancel consumer:" +consumerTag);});
                   System.out.println("worker consumer tag:" + tag);
                   
                   // Register the second consumer on the channel.
                   /*final String tag2 = channel.basicConsume(DEFAULT_WORKER_QUEUE, false, deliverCallback, consumerTag -> {System.out.println("Cancel consumer:" +consumerTag);});
                   System.out.println("worker consumer#2 tag:" + tag2);*/
               } else { // Pull mode
                   final boolean autoAck = false;
                   while (true) {                        
                       final GetResponse getResponse = channel.basicGet(DEFAULT_WORKER_QUEUE, autoAck);
                       handleGettedMsg(getResponse, autoAck);
                   }                    
               }                
           } catch (IOException e) {
               e.printStackTrace();                
           }                   
       }        
   }    
   
   private static class Producer implements Runnable {
       private static final int MSG_COUNTS = 10;
       private final Connection connection;
       
       public Producer(Connection connection) {
           this.connection = connection;            
       }
       
       @Override
       public void run() {
           try {
               final Channel channel = connection.createChannel();
               channel.exchangeDeclare(NORMAL_EXCHANGE, "direct");                
               channel.queueDeclare(DEFAULT_WORKER_QUEUE, false, false, true, null);
               channel.queueBind(DEFAULT_WORKER_QUEUE, NORMAL_EXCHANGE, NORMAL_ROUTE_KEY);

               for (int i = 0; i < MSG_COUNTS; i++) {
                   final BasicProperties.Builder propsBuilder = new BasicProperties.Builder();
                   final BasicProperties props = propsBuilder.appId(Thread.currentThread().toString()).messageId(String.valueOf(i)).build();
                                       
                   channel.basicPublish(NORMAL_EXCHANGE, NORMAL_ROUTE_KEY, props, "[normal message.]".getBytes());                    
               }                
           } catch(IOException e) {
               e.printStackTrace();
           }
       }        
   }
   
   public QSQueue() {
       executorService = Executors.newCachedThreadPool(new SimpleThreadFactory());
       
       final ConnectionFactory connectionFactory = new ConnectionFactory();
       connectionFactory.setHost("localhost");
       try {
           connection = connectionFactory.newConnection();
       } catch (IOException | TimeoutException e) {
           e.printStackTrace();
       }        
   }
   
   public void execWorkderConsumer(boolean pushMode) {
       executorService.submit(new WorkerConsumer(connection, pushMode));               
   }  
   
   public void execProducer(int n) {
       for (int i = 0; i < n; i++) {
           executorService.submit(new Producer(connection));
       }        
   } 
   
   public void clearConfig(String[] queues) {
       try {
           final Channel channel = connection.createChannel();
           channel.exchangeDelete(NORMAL_EXCHANGE);
           channel.queueDelete(DEFAULT_WORKER_QUEUE);
           for (String queue : queues) {
               channel.queueDelete(queue);
           }
           System.out.println("Config cleared.");
           System.exit(0);
       } catch(IOException e) {
           e.printStackTrace();            
       }        
   }
   
   public static void main(String args[]) {
       System.out.println("QS queue.");
       if (args.length > 0) {
           final String which = args[0];                    
           if ("consumer".equals(which)) {
               final boolean pushMode = (args.length > 1 ? "push".equals(args[1]) : true);
               new QSQueue().execWorkderConsumer(pushMode);            
           } else if ("producer".equals(which)) {
               final int n = (args.length > 1 ? Integer.parseInt(args[1]) : 1);
               new QSQueue().execProducer(n);            
           } else if ("clearconfig".equals(which)) {
               String[] queues = new String[0];
               if (args.length > 1) {
                   queues = new String[args.length - 1];
                   System.arraycopy(args, 1, queues, 0, args.length - 1);
               }
               new QSQueue().clearConfig(queues);                
           }
       }                     
   }
}

其中,为了模拟consumer处理一个重负载的消息, 调用了Thread.sleep进行休眠操作.

将该类导出为Runnable JAR包, 打开一个控制台终端,运行一个consumer:

java -jar qsqueue.jar consumer

打开另一个控制台终端, 运行一个producer:

java -jar qsqueue.jar producer

produce中将发送10个消息, 由于consumer中休眠的时间比较长, 可以通过RabbitMQ的management UI查看服务器节点上的消息情况.一开始时, 显示如下信息:

也就是说, 有两个消息已经投递到了consumer等待确认, 有八个消息处于等待投递状态.随着consumer对消息的确认,和RabbitMQ服务器不断的投递消息,服务器最终将处理完所有消息.

basicQos API
basicQos API实在channel实例上进行调用的, 该函数的签名为:

void basicQos(int prefetchSize, int prefetchCount, boolean global) throws IOException

该函数API需要注意的几个细节有:

• 根据签名可以看出, 进行预取时, 可以根据消息大小预取, 此时, 不包含消息属性占用的字节数,也不包含RabbitMQ服务器为消息添加的Envelope结构的大小.当参数prefetchSize设置为0时, 表示不对消息大小进行限制,即RabbitMQ服务器会投递尽可能多的消息到consumer.
• 也可以根据消息个数预取. 示例中使用的是消息个数进行预取.参数prefetchCount的含义表示RabbitMQ服务器节点上最多的没有确认的消息个数. 这个参数设置为0时,表示不对消息个数进行限制, RabbitMQ服务器会投递尽可能多的消息到consumer.
• RabbitMQ服务器根据consumer设置的prefetchSize和prefetchCount中最小满足条件进行消息投递. 示例中prefetchSize设置为0, prefetchCount设置为2, 则RabbitMQ会根据消息个数设置条件进行消息投递. 处理流程为:RabbitMQ向consumer投递消息#1和#2, 此时服务器上消息统计信息为Ready为8, Unacked为2, Total为10. 当consumer处理玩消息#1并向服务器确认后, 服务器将向consumer投递消息#3, 此时服务器上的消息统计信息为Ready为7, Unacked为2, Total为9.
• basicQos API的第三个参数global的含义是, 预取是channel全局设置,还是在该channel上的每个consumer上的设置.可以在channel上注册多个consumer, 但是因为消息在同一个channel中是顺序处理的, 因此这种场景实际意义并不大. 示例代码中取消注释掉的第二个consumer, 重新运行后, RabbitMQ第一次投递消息后的统计信息为:
  也就是说, 当一个channel实例上注册有两个consumer时,如果global参数设置为false, 每个consumer上最多有2个未确认消息, 而服务器节点上将最多有4个未确认消息.

Pull 模式
可以使用basicGet API获取RabbitMQ服务器节点上的消息,这个API每次获取一个消息. 但是该方式效率不高, 建议注册consumer, 使用push模式对消息进行处理.另一个细节是, pull模式的消息处理是在该API调用线程进行处理的, 而push模式中, 消息在DeliverCallback回调中处理, 这和consumer的注册线程不是同一个线程.

小结:
当使用basicQos API对push模式的consumer进行预取时, 如果consumer设置了自动确认, basicQos API不会起作用, 其没有任何意义.

BTW: 因为这个示例导出的Runnable JAR包中包含了RabbitMQ的Java客户端库,所以可以直接运行. 否则,运行时需要在classpath中指定其客户端库路径.