JMS Message Consumer Rate Limiting

With ActiveMQ you can specify a maximum consume rate at which a JMS MessageConsumer will consume messages. This can be specified when creating or deploying the connection factory. See hornetq-jms.xml

If this value is specified then ActiveMQ will ensure that messages are never consumed at a rate higher than the specified rate. This is a form of consumer throttling.

Example step-by-step

In this example we specify a consumer-max-rate of 10 messages per second in the hornetq-jms.xml file when deploying the connection factory:

     
   <connection-factory name="ConnectionFactory">
      <connector-ref connector-name="netty-connector"/>
      <entries>
         <entry name="ConnectionFactory"/>       
      </entries>
      
      <!-- We limit consumers created on this connection factory to consume messages at a maximum rate
      of 10 messages per sec -->
      <consumer-max-rate>50</producer-max-rate>
      
   </connection-factory>

We then simply consume as many messages as we can in 10 seconds and note how many messages are actually consumed.

We note that the number of messages consumed per second never exceeds the specified value of 10 messages per second.

To run the example, simply type mvn verify from this directory

  1. Create an initial context to perform the JNDI lookup.
    2.            initialContext = getContext(0);
  2. Perfom a lookup on the queue
    3.            Queue queue = (Queue)initialContext.lookup("/queue/exampleQueue");
  3. Perform a lookup on the Connection Factory
    4.            ConnectionFactory cf = (ConnectionFactory)initialContext.lookup("/ConnectionFactory");
  4. Create a JMS Connection
    5.            connection = cf.createConnection();
  5. Create a JMS Session
    6.            Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
  6. Create a JMS MessageProducer
    7.           MessageProducer producer = session.createProducer(queue);
  7. Create a JMS MessageConsumer
    8.            MessageConsumer consumer = session.createConsumer(queue);
  8. Start the connection
    9.            
     connection.start();
  9. Send a bunch of messages
    10.            
     final int numMessages = 150;
         
     for (int i = 0; i < numMessages; i++)
     {
        TextMessage message = session.createTextMessage("This is text message: " + i);

        producer.send(message);
     }
  10. Consume as many messages as we can in 10 seconds
    11.            
   final long duration = 10000;

   int i = 0;

   long start = System.currentTimeMillis();

   while (System.currentTimeMillis() - start <= duration)
   {
      TextMessage message = (TextMessage)consumer.receive(2000);

      if (message == null)
      {
         return false;
      }
      
      i++;
   }

   long end = System.currentTimeMillis();

   double rate = 1000 * (double)i / (end - start);

   System.out.println("We consumed " + i + " messages in " + (end - start) + " milliseconds");

   System.out.println("Actual consume rate was " + rate + " messages per second");
  11. This should produce output something like:
    12.            
    [java] Sent messages
    [java] Will now try and consume as many as we can in 10 seconds ...
    [java] We consumed 100 messages in 10001 milliseconds
    [java] Actual consume rate was 9.99900009999 messages per second
  12. Be sure to close our resources!
    13.            
           finally
           {
              if (initialContext != null)
              {
                initialContext.close();
              }
              
              if (connection != null)
              {
                 connection.close();
              }
           }