How to Implement Consumer‑Side Throttling in RabbitMQ

Interview Focus

QoS mechanism : basic.qos and prefetchCount control the rate of message delivery to consumers.

Manual ACK : Throttling only works when automatic ACK is disabled and manual ACK is used.

Parameter details : prefetchCount can be set at the channel or consumer level; the global flag has special semantics in RabbitMQ.

Core Answer

RabbitMQ uses basic.qos to set prefetchCount, limiting the number of unacknowledged messages the broker can push to a consumer. The broker sends at most prefetchCount messages without ACK; when a consumer ACKs a message, the broker pushes another, keeping the in‑flight count at or below the limit.

Prerequisite : Automatic ACK must be turned off; otherwise the broker treats messages as already acknowledged and prefetchCount has no effect.

Key Parameters

prefetchCount

– maximum number of unacknowledged messages per consumer (typical 1‑100). prefetchSize – maximum total size of unacknowledged messages (0 means unlimited, usually set to 0). global – whether the setting applies to the entire channel (RabbitMQ treats true differently from the AMQP spec).

Deep Analysis – How Throttling Works

prefetchCount = 3

means the broker will never have more than three unacknowledged messages for that consumer.

When the consumer processes message 1 and sends an ACK, the broker immediately pushes message 4, keeping the in‑flight count at three.

If the consumer processes slowly and ACKs are delayed, the broker stops pushing new messages, preventing the consumer from being overwhelmed.

Choosing an appropriate prefetchCount depends on business characteristics: a small value (e.g., 1) limits throughput, while a very large value defeats throttling. Typical ranges are 10‑50 for order processing and 100‑500 for log consumption; performance testing is recommended before production deployment.

Code Example – Native RabbitMQ Java Client

Channel channel = connection.createChannel();

// Disable automatic ACK (manual ACK mode)
channel.basicConsume("order.queue", false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope,
                               AMQP.BasicProperties properties, byte[] body) {
        try {
            // Process the message
            processOrder(body);
            // Manual ACK
            channel.basicAck(envelope.getDeliveryTag(), false);
        } catch (Exception e) {
            // On failure, reject and requeue
            channel.basicNack(envelope.getDeliveryTag(), false, true);
        }
    }
});

// Set QoS: prefetchCount = 10
channel.basicQos(10);

Spring Boot configuration simplifies the same settings:

spring:
  rabbitmq:
    listener:
      simple:
        acknowledge-mode: manual   # manual ACK
        prefetch: 10                # prefetchCount

Pitfall of the global Flag

RabbitMQ’s global parameter behaves differently from the AMQP specification: global = false: limits a single consumer – consistent with the spec. global = true: limits only consumers created after the call on the same channel, not a shared limit across all consumers – deviates from the spec.

In practice, developers usually set global = false and apply throttling at the consumer level.

Common Misconceptions

Setting prefetchCount alone is insufficient; manual ACK must be enabled, otherwise throttling is ineffective.

“Bigger prefetchCount is better” is wrong – an excessively large value removes throttling, while a too‑small value harms throughput. prefetchCount controls the number of concurrent unacknowledged messages, not the per‑second delivery rate.

High‑Frequency Follow‑Up Questions

How many is a suitable prefetchCount ? No universal answer; fast processing (milliseconds) may use 50‑100, slow processing (external calls, DB writes) may use 5‑20. Adjust after load testing.

Default prefetch in Spring AMQP? Before Spring AMQP 2.0 the default is 1; from 2.0 onward it is 250, which is often too high and should be configured explicitly.

If multiple consumers share a queue, how does prefetchCount work? Each consumer maintains its own count; two consumers with prefetchCount = 10 can each receive up to ten messages simultaneously, independent of each other.

Typical Interview Variants

"What to do when a RabbitMQ consumer can’t keep up?"

"Do you understand RabbitMQ’s QoS mechanism?"

"What does the prefetchCount parameter do?"

Memory Mnemonic

Three steps for throttling: basicQos → set prefetchCount, disable automatic ACK, and ACK each message after processing. Remember that prefetchCount limits concurrent in‑flight messages, not per‑second rate.

Summary

Consumer‑side throttling in RabbitMQ relies on the

basic.qos

prefetchCount

setting, which caps the number of unacknowledged messages a broker can deliver. It must be used with manual ACK; otherwise the limit is ignored. The exact prefetchCount value should be tuned to the workload, and the global flag is usually left false to apply limits per consumer.