Latches & Countdowns

1#include <latch>
2#include <thread>
3 
4std::latch warmups{3};                       // one-shot, cannot be reset
5 
6auto worker = [&](auto fn) {
7  fn();
8  warmups.count_down();                      // atomic; UB if it goes past zero
9};
10 
11std::jthread t1(worker, fill_pool);
12std::jthread t2(worker, load_table);
13std::jthread t3(worker, fetch_flags);
14 
15warmups.wait();                              // blocks THIS thread until zero
16start_accepting_traffic();
17// Later waiters return immediately: the gate is open permanently.

A real primitive: count_down is an atomic decrement plus a notify, and wait blocks the calling OS thread. Counting down more times than the initial count is undefined behaviour, so double-signal is a bug the language will not catch in release builds. arrive_and_wait combines both roles for a participant that also waits.

1// No latch primitive. Build one — the decrement is atomic on this loop.
2function createLatch(n) {
3  let remaining = n
4  const signalled = new Set()          // idempotence is YOUR job
5  let open
6  const gate = new Promise((resolve) => { open = resolve })
7  return {
8    countDown(id) {
9      if (signalled.has(id)) return    // a retry path must not open the gate early
10      signalled.add(id)
11      remaining -= 1                   // no await between read and write: atomic here
12      if (remaining === 0) open()
13    },
14    wait: () => gate,                  // late waiters get the settled promise instantly
15  }
16}
17 
18const latch = createLatch(3)
19fillPool().then(() => latch.countDown('pool'))
20loadTable().then(() => latch.countDown('table'))
21fetchFlags().then(() => latch.countDown('flags'))
22await latch.wait()

The promise IS the gate: it settles once and every later waiter gets the settled value immediately, which is exactly latch semantics for free. What the language does not give you is protection against a double count-down, so key the signal by worker id.

1// The honest version: if the workers can fail, a latch hides it.
2// A latch only counts DOWN — it has no channel for "worker 2 threw".
3type WarmUp = { name: string; run: () => Promise<void> }
4 
5async function warmUp(tasks: WarmUp[], timeoutMs: number): Promise<void> {
6  const results = await Promise.race([
7    Promise.allSettled(tasks.map((t) => t.run())),
8    new Promise<never>((_, rej) =>
9      setTimeout(() => rej(new Error('warm-up timed out')), timeoutMs)),
10  ])
11  const failed = results
12    .map((r, i) => ({ r, name: tasks[i].name }))
13    .filter((x) => x.r.status === 'rejected')
14  if (failed.length) {
15    throw new AggregateError(failed.map((f) => (f.r as PromiseRejectedResult).reason),
16      'warm-up failed: ' + failed.map((f) => f.name).join(', '))
17  }
18}

Reaching for a latch when the workers can fail is usually the wrong call: the counter has no way to express failure, so a crashed worker becomes a hang. allSettled plus a timeout gives you the same rendezvous AND names which subsystem failed.

1import asyncio
2 
3# asyncio has no latch. Event + counter is the direct translation.
4class Latch:
5    def __init__(self, n: int) -> None:
6        self._remaining = n
7        self._event = asyncio.Event()
8        self._signalled: set[str] = set()
9 
10    def count_down(self, key: str) -> None:
11        if key in self._signalled:          # idempotent per worker
12            return
13        self._signalled.add(key)
14        self._remaining -= 1                # atomic on the loop: no await inside
15        if self._remaining == 0:
16            self._event.set()               # stays set forever — latch semantics
17 
18    async def wait(self) -> None:
19        await self._event.wait()
20 
21# Usually you do not need it: gather IS the rendezvous, and it propagates errors.
22await asyncio.gather(fill_pool(), load_table(), fetch_flags())

asyncio.Event is one-shot in exactly the way a latch is: once set it stays set and later waiters return immediately. But for "wait for these N coroutines", gather is simpler and, unlike a latch, surfaces a failure instead of turning it into a hang.