Competing consumers — N workers, one head

Pointing N workers at one queue makes them compete for messages from a single head; throughput scales linearly with worker count until the producer rate is the bottleneck.

Previously

We had one producer and one consumer on a tidy strip. Real workloads need throughput, so we point N workers at the same head and let the broker hand each message to whichever worker is ready.

Scene 04

Competing consumers — N workers, one head

Watch
Try it
Predict
Capture

What to watch for

One worker can't keep up with the producer — watch the strip grow. Each new worker shares the same head, and a cell goes to EXACTLY ONE worker (no duplicate colors across the stack). Three workers is enough to drain the queue at this rate.

Implementation

Highlighted lines are the ones running in the diagram right now.

Broker.handOutNext(workers)

atomic pop at the head — one cell goes to exactly one worker

1# called by each ready worker; runs under a head lock
2def handOutNext(workerId):
3    with head_lock:
4        if headIndex >= len(events):
5            return None  # queue empty
6        cell = events[headIndex]
7        cell.takenBy = workerId
8        headIndex += 1   # advance past this cell
9    return cell

Worker.loop()

pull from the shared head, process, repeat

1def run(workerId):
2    while True:
3        cell = broker.handOutNext(workerId)
4        if cell is None:
5            sleep(poll_backoff_ms)
6            continue
7        process(cell)        # ~1 / per_worker_rate seconds
8        # ack is implicit here — see next scene for the split

System.throughput

drain capacity capped by whoever is slower

1# steady-state system throughput, in msg/s
2def systemThroughput(N, producerRate, perWorkerRate):
3    drainCapacity = N * perWorkerRate
4    return min(producerRate, drainCapacity)
5 
6# below the knee:  N * perWorkerRate < producerRate
7#   -> drain-bound; depth grows; add workers to keep up
8# above the knee:  N * perWorkerRate >= producerRate
9#   -> producer-bound; depth flat; extra workers idle

Where this sits in Build a Message Queue (RabbitMQ / SQS)

Scene 04 of 14. Point N workers at the same head; the broker hands each cell to whichever worker is ready. Throughput scales linearly until producer rate caps it.

Up next. Each message goes to exactly one worker — but how does the broker know the worker actually finished? Right now we cheat: dequeue is atomic delete. Real systems split that into two halves with a consumer-side signal in the middle.

All 14 scenes in Build a Message Queue (RabbitMQ / SQS) · Every curriculum

Built with Arqly

Every scene in Build a Message Queue (RabbitMQ / SQS) builds on the one before it.All 14 Build a Message Queue (RabbitMQ / SQS) scenes