# JMS Message Producer Rate Limiting

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

If this value is specified then HornetQ will ensure that messages are never produced at a rate higher than specified. This is a form of producer throttling.

## Example step-by-step

In this example we specify a `producer-max-rate` of `50` 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 producers created on this connection factory to produce messages at a maximum rate
          of 50 messages per sec -->
          <producer-max-rate>50</producer-max-rate>

       </connection-factory>

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

We note that the number of messages sent per second never exceeds the specified value of `50` messages per second.

To run the example, simply type `./build.sh` (or `build.bat` on windows) from this directory

1. Create an initial context to perform the JNDI lookup.

               initialContext = getContext(0);

2. Perfom a lookup on the queue

               Queue queue = (Queue)initialContext.lookup("/queue/exampleQueue");

3. Perform a lookup on the Connection Factory

               ConnectionFactory cf = (ConnectionFactory)initialContext.lookup("/ConnectionFactory");

4. Create a JMS Connection

               connection = cf.createConnection();

5. Create a JMS Session

               Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

6. Create a JMS Message Producer

              MessageProducer producer = session.createProducer(queue);

7. Send as many messages as we can in 10 seconds

            final long duration = 10000;

            int i = 0;

            long start = System.currentTimeMillis();

            while (System.currentTimeMillis() - start <= duration)
            {
               TextMessage message = session.createTextMessage("This is text message: " + i++);

               producer.send(message);
            }

            long end = System.currentTimeMillis();

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

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

            System.out.println("Actual send rate was " + rate + " messages per second");

8. We note that the sending rate doesn't exceed 50 messages per second. Here's some example output from a real run

         [java] Will now send as many messages as we can in 10 seconds...
         [java] We sent 500 messages in 10072 milliseconds
         [java] Actual send rate was 49.64257347100874 messages per second

9. For good measure we consumer the messages we produced.

            MessageConsumer messageConsumer = session.createConsumer(queue);

            connection.start();

            System.out.println("Now consuming the messages...");

            i = 0;
            while (true)
            {
               TextMessage messageReceived = (TextMessage)messageConsumer.receive(5000);

               if (messageReceived == null)
               {
                  break;
               }

               i++;
            }

            System.out.println("Received " + i + " messages");

10. Be sure to close our resources!

               finally
               {
                  if (initialContext != null)
                  {
                    initialContext.close();
                  }

                  if (connection != null)
                  {
                     connection.close();
                  }
               }