Practices for Improving RabbitMQ Consumption Speed

Increase Consumers

Adding more consumer instances can raise throughput, but it requires sufficient backend resources such as database connections and careful handling of concurrency conflicts and message ordering.

Increase Prefetch Count

Prefetch count controls how many messages are sent to a consumer before acknowledgments; setting an appropriate value keeps the pipeline full and improves throughput, similar to TCP flow control.

Multithreaded Processing

Using multiple threads within a single consumer avoids opening many connections and allows parallel handling of messages. Example code shows registering a Received event and dispatching messages to the thread pool.

consumer.Received += (o, e) => 
{
    ThreadPool.QueueUserWorkItem(new WaitCallback(ProcessSingleContextMessage), e);
};

A more advanced example groups messages by a data key, processes each group sequentially while running groups in parallel.

// receive messages, batch when count >= prefetchCount/2
consumer.Received += (o, e) =>
{
    lock(receiveLocker){
        basicDeliverEventArgsList.Add(e);
        if (basicDeliverEventArgsList.Count >= prefetchCount/2)
        {
            var deliverEventArgs = basicDeliverEventArgsList.ToArray();
            basicDeliverEventArgsList.Clear();
            EnProcessQueue(deliverEventArgs);
        }
    }
};
...
private void Process(BasicDeliverEventArgs[] args)
{
    if (args.Length <= 0) return;
    try
    {
        var tasks = CreateParallelProcessTasksByDataKey(args);
        Task.WaitAll(tasks);
    }
    catch (Exception ex)
    {
        ToLog("处理任务发生异常", ex);
    }
}

Batch Acknowledgment

Sending a single acknowledgment for multiple messages reduces network round‑trips. Setting the second parameter of BasicAck to true acknowledges all messages with a lower delivery tag.

channel.BasicAck(e.DeliveryTag, true);

When some messages may fail, batch ack must be used carefully to avoid losing unprocessed messages.

Overall Recommendations

Enable and tune Prefetch count.

Start with a single consumer processing one message at a time.

If needed, increase the number of messages per fetch while preserving order.

Introduce parallel processing within the consumer.

Scale out by adding more consumer instances.

If performance is still insufficient, reconsider requirements or switch middleware.

Throughout, monitor backend performance, optimize SQL, use caching, and handle duplicate, concurrency, and ordering issues appropriately.