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. It does not park on the work list. It parks on a dedicated marker ZSET, emq:{queue}:marker, with BZPOPMIN — a doorbell. When a producer adds a job to wait, it also ZADDs a member onto the marker, which makes the parked BZPOPMIN return; the worker then fetches the job from wait on its main connection. Same trade as BLMOVE — block instead of poll, wake the instant work arrives, burn no idle round-trips — applied through a separate signalling key rather than the work list.

The naive wait is a spin: RPOP wait; 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 BZPOPMIN 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 busy — a command sent on the same connection waits behind the block. EchoMQ avoids that by parking the block on a dedicated blocking connection (EchoMQ.RedisConnection.blocking_connection/1, documented as "a dedicated blocking connection for operations like BRPOPLPUSH or BZPOPMIN"), leaving the worker's main command connection free for fetches and acknowledgements. The second dive builds the primitive and the dedicated-connection discipline.

EchoMQ's blocking-fetch path makes the handshake precise. The worker parks on emq:{queue}:marker — a ZSET, built by EchoMQ.Keys.marker/1 and documented as the "marker sorted set (for blocking operations)". The blocking-fetch internals are EchoMQ.Worker.wait_for_job/2 → do_wait_for_job/3 (both private worker functions): do_wait_for_job/3 runs BZPOPMIN marker_key timeout and returns :job_available when a marker arrived or :timeout when none did.

The producer side rings the doorbell: adding a job runs addBaseMarkerIfNeeded, which is ZADD emq:{queue}:marker 0 "0" (verified in addStandardJob-9.lua and drain-5.lua). The ZADD makes the parked BZPOPMIN return, and the worker fetches the job. The marker is a signal, not a queue: BZPOPMIN pops the lowest-scored member, so one ZADD wakes one parked BZPOPMIN. The third dive walks the full handshake and the fan-out fairness.

# EchoMQ.Worker.do_wait_for_job/3 — park on the marker, wake when a job is added (real, Elixir)
case Redix.command(conn, ["BZPOPMIN", marker_key, timeout_seconds], timeout: :infinity) do
  {:ok, nil}                  -> :timeout         # the park elapsed, no job
  {:ok, [_key, _member, _sc]} -> :job_available   # a marker arrived → a job is available
end

Block 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.

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-specific marker handshake that wakes the worker. Read them in order — the cost first, the primitive second, the marker wake-up third.

The Redis primitives behind the blocking wait — the marker pop, the blocking moves, the sorted set, and the ZADD that rings it — and where the engine that parks on them is taught.