Blocking vs polling.

The source's reliable-queue loop, in polling form, pops the work list and falls back to a sleep: pop; if the result is nil, sleep a fixed interval; retry. For efficient consumption without polling, the source offers the blocking form — BLMOVE work_queue processing RIGHT LEFT 30 — which waits up to thirty seconds for a message. If the queue is empty, the connection parks on the server rather than returning immediately. There is no poll interval and no wasted round-trip: the call returns the instant an element is available, or after the timeout elapses.

EchoMQ keeps the idea and changes the primitive. The consumer does not park on the work list. It parks on a dedicated wake key, emq:{queue}:wake — a short capped list — with BLPOP emq:{queue}:wake <beat>. When a producer admits a job, the admit script runs LPUSH emq:{queue}:wake '1' (then LTRIM emq:{queue}:wake 0 63 to bound the list), which returns the parked BLPOP; the consumer then drains the ring with EchoMQ.Lanes.claim/3. Same trade as BLMOVE — park instead of poll, wake the instant work arrives, burn no idle round-trips — applied through a separate signalling key, so a wake fires no matter which lane the new work landed on.

The naive wait is a spin: pop the work list; if the result is nil, sleep(interval); repeat. Every pass that returns nil is a wasted round-trip — a command sent and a nil sent back, for no work. On a queue that is empty most of the time, that is the steady state.

A job rarely arrives exactly when the worker polls. It arrives in the gap between two polls and waits the rest of the gap before the next poll picks it up, so average pickup latency is about half the interval. The interval is the only dial, and it has no good setting: a short interval cuts latency but multiplies the empty round-trips on an idle queue; a long interval cuts the round-trips but lengthens pickup latency. No value is cheap on both axes, because polling pays for checking whether work exists separately from doing the work. The first dive quantifies the trade with a poll-cost calculator.

A blocking pop — BLMOVE, BRPOPLPUSH, or BLPOP with a timeout — parks the connection on the server until an element is available or the timeout elapses. There is no poll interval, so a job is picked up the moment it arrives, not up to one interval later. There are no empty round-trips, because the call does not return until there is work or the timeout fires.

The cost is the connection. While a connection is parked on a blocking call, it is occupied — a command sent on the same connection waits behind the block. EchoMQ parks the block on a dedicated connector lane (the consumer's moduledoc: "a dedicated connector — blocking verbs get their own lane"), so the lane that drains and settles jobs is never tied up by a park. The second dive builds the primitive and the dedicated-connection discipline.

EchoMQ's consumer loop makes the handshake precise. The loop is reap → promote → drain → park, repeating: it reaps expired leases, promotes due schedules, drains the ring with rotating claims, then parks on the wake key with BLPOP emq:{queue}:wake <beat> until readiness arrives as a wake or the beat elapses.

The producer side rings the doorbell from inside the admit Lua: pushing a job onto the ring runs LPUSH emq:{queue}:wake '1', then LTRIM emq:{queue}:wake 0 63 to cap the list at 64 tokens (the same two calls appear in the promote and reclaim scripts in jobs.ex, lanes.ex, and stalled.ex). The LPUSH returns the parked BLPOP, and the consumer drains. The wake key is a signal, not a queue: BLPOP pops one element, so one LPUSH returns one parked block. The beat (:beat_ms, default 1000) is the fallback: when no wake arrives, the BLPOP times out and the loop runs its reap/promote pump anyway, so a due schedule or an expired lease is never stranded. The third dive walks the full handshake and the pool's one-blocker EchoMQ.Metronome.

Park instead of poll whenever a worker waits on a queue that is empty much of the time and pickup latency matters. A busy-poll loop is acceptable only when a blocking connection is not available, or when the producer cannot ring a signal and the worker must re-check on its own cadence. Otherwise the blocking form wins on both axes it trades against: lower latency and fewer round-trips at once. EchoMQ takes a third position for a pool — one EchoMQ.Metronome holds the single block per queue and pokes idle consumers, so the connection cost of blocking is paid once, not once per worker.

Each dive takes one part of the move, in order: the cost the polling loop pays, the blocking primitive that removes it, and the EchoMQ wake handshake that returns the parked consumer.