Concurrency

blocks the calling thread until a full line (or EOF) arrives on stdin.

writes to the shared std::cout; concurrent prints from several threads do not race but may interleave their characters.

writes to the shared std::cout; concurrent prints from several threads do not race but may interleave their characters.

deliberately single-threaded (the fastest-per-core contract); parallelize across independent products in the caller.

called by the owner with its coordinator mutex held — never construct one yourself.

the handler never fires asynchronously — only from inside a valid() call, on the thread that polls it.

race-free while the lease is held: a writer cannot proceed until this lease releases (yielding on !valid() is cooperative, not forced). No lock is taken here.

an atomic acquire load; the first observation of a stop acks and wakes the owner (that one call briefly takes the owner's mutex) — polling this from the holding thread is what lets a drain/preempt make progress. The lease handle itself is not internally synchronized: poll from the thread that holds the lease.

exclusive: no reader or other writer coexists while this lease is valid. A writer that observed !valid() (an immediate-write preempted it) must wait for valid() to flip back before writing again — writing while suspended races with the immediate-write.

the release callback takes the owner's coordinator mutex and wakes waiting requests (a draining writer proceeds once the last reader releases here).

construct before sharing; the pinned Owner must outlive every lease and every thread that uses it.

callable from any thread; readers share. Writer-preference: this waits while any write is active, suspended, or queued, so writers cannot starve.

callable from any thread. Drain-before-write: flips the current read generation's gate and waits until every reader has released and no other write is active; an immediate-write skips the queue and additionally preempts a cooperating active writer (which resumes after).

one-shot: a second acquire() on the same request throws std::future_error. on_interrupt later fires on whichever thread polls the lease's valid() — never asynchronously.

thread-safe — draws its index from the per-thread engine via randint.

thread-safe — draws from the per-thread (thread_local) engine, so concurrent draws never race.

thread-safe — draws from the per-thread (thread_local) engine, so concurrent draws never race.

thread-safe — draws from the per-thread (thread_local) engine, so concurrent draws never race.

seeds the calling thread's engine only; other threads' streams are unaffected.

thread-safe — draws from the per-thread (thread_local) engine, so concurrent draws never race.

blocking, with every hop's socket I/O bounded by timeout_ms; no shared state — concurrent requests from separate threads are independent.

blocks the calling thread until a client connects.

blocks until data, EOF, or the set_timeout() deadline.

blocks until the TCP handshake completes or fails.

blocks the calling thread until a client connects.

blocks until the TCP handshake completes or fails.

blocks until data, EOF, or the set_timeout() deadline; a shutdown() from another thread wakes it with EOF.

may block while the peer's receive window is full; bounded per send by the set_timeout() send deadline.

safe to call from another thread while a recv() on fd blocks — waking that reader is exactly what it is for.

blocks until the TCP handshake completes or fails.

the worker may already be running before spawn returns. Copyable arguments are captured before the thread starts, so the caller may immediately mutate or destroy its originals; a by-reference argument (a pinned memory.Owner) is shared with the running worker from that moment on.

the handle itself is not internally synchronized — drive a given Thread from one thread at a time (the worker it owns is, of course, another thread; join() is the synchronization point with it).

blocks the calling thread; the worker's writes happen-before join() returns (the join is the synchronization). One-shot — a second join raises.

may block: the destination joins its old worker before adopting the new one.

the worker is already running when the handle adopts it.

blocks the destroying thread until the worker finishes — on every exit path, including unwinding.

blocks only the calling thread; other threads keep running.

blocks awaiting the client's handshake flights — bound it with socket.set_timeout() on fd so a silent client cannot hang the server.

blocks (bounded by the fd's socket.set_timeout()) only while nothing is ready; a session has ONE reader — shutdown() is the cross-thread wake-up.

a session is single-owner — never send on one session from two threads at once (the record sequence would race). Separate sessions are independent.

safe to call from another thread while the owner's recv() blocks — that wake-up is its purpose; then join the reader before close().

the error slot is thread-local — read it on the thread whose call failed.

blocks for the handshake round trip — bound it with socket.set_timeout() on fd.

blocks until a full message arrives; a session has ONE reader — shutdown() is the cross-thread wake-up.

safe to call from another thread while the owner's recv() blocks — that wake-up is its purpose; then join the reader before close().

blocks for the TCP/TLS/upgrade round trips.

blocks for the TCP/TLS/upgrade round trips.

every routine is DELIBERATELY single-threaded (no hidden thread pool — the fastest-per-core contract); the caller composes parallelism across independent problems.