src/sync.zig

Página generada desde zkit@zkit-0.0.0-_fk2iAa4BQCqGFKJeeY9WvMQClX5kiZQ2iOZrVsxVyyN (src/root.zig). No se edita a mano: bun run docs:gen la regenera y bun run docs:check falla si difiere.

zkit/sync — Mutex y Condition bloqueantes sobre pthread, sin runtime Io.

Desde 0.16 std.Thread.Mutex/Condition no existen: el mutex bloqueante vive en std.Io.Mutex y exige un Io. Una librería con hilos propios (std.Thread.spawn) no tiene uno, así que cada consumidor escribió su capa pthread (styx: backpressure_waker.zig más 60 usos de pthread_mutex_t crudo; hyperdiff: watch/sync.zig). Ésta es la única.

Diseño:

• Los dos tipos se inicializan por valor (.{} = PTHREAD_*_INITIALIZER): no hay init que olvidar ni error.MutexInitFailed que propagar. El deinit existe para simetría y es opcional sobre un mutex estático.
• lock/unlock/wait sólo fallan por bugs (EINVAL, EDEADLK, EPERM): se promueven a pánico, nunca se ignoran.
• timedWait mide contra el reloj MONOTÓNICO siempre que la plataforma lo permita (glibc ≥ 2.30 pthread_cond_clockwait, Darwin pthread_cond_timedwait_relative_np); un salto del reloj de pared no alarga ni acorta la espera. En musl / BSD cae a CLOCK_REALTIME, y el bucle de waitUntil recorta contra el plazo monotónico igualmente.
• TSAN entiende pthread por interceptores: no hace falta anotar nada.

Para detectar inversiones de orden de locks y unlocks desde otro hilo usa zkit.safety.Mutex, que envuelve éste.

sync.MutexCopiar enlace

type · línea 54

pub const Mutex = struct

Mutex no recursivo con atributos por defecto.

sync.Mutex.deinitCopiar enlace

fn · línea 57

pub fn deinit(m: *Mutex) void

Sin ///.

sync.Mutex.lockCopiar enlace

fn · línea 62

pub fn lock(m: *Mutex) void

Sin ///.

sync.Mutex.tryLockCopiar enlace

fn · línea 70

pub fn tryLock(m: *Mutex) bool

true si el lock se tomó; false si otro hilo lo tiene.

sync.Mutex.unlockCopiar enlace

fn · línea 78

pub fn unlock(m: *Mutex) void

Sin ///.

sync.Mutex.acquireCopiar enlace

fn · línea 86

pub fn acquire(m: *Mutex) Held

Guarda para defer: var held = m.acquire(); defer held.release();.

sync.Mutex.HeldCopiar enlace

type · línea 91

pub const Held = struct

Sin ///.

sync.Mutex.Held.releaseCopiar enlace

fn · línea 94

pub fn release(self: Held) void

Sin ///.

sync.TimedWaitErrorCopiar enlace

const · línea 100

pub const TimedWaitError = error{Timeout}

Sin ///.

sync.ConditionCopiar enlace

type · línea 105

pub const Condition = struct

Variable de condición. Se asocia a un Mutex en cada wait. Los despertares espurios son posibles: el llamador re-comprueba su predicado en bucle.

sync.Condition.deinitCopiar enlace

fn · línea 108

pub fn deinit(cond: *Condition) void

Sin ///.

sync.Condition.waitCopiar enlace

fn · línea 115

pub fn wait(cond: *Condition, mutex: *Mutex) void

Libera mutex (que el llamador sostiene), duerme hasta una señal y lo vuelve a tomar antes de volver.

sync.Condition.timedWaitCopiar enlace

fn · línea 124

pub fn timedWait(cond: *Condition, mutex: *Mutex, timeout_ns: u64) TimedWaitError!void

Como wait, pero como mucho timeout_ns. error.Timeout si venció sin señal. Puede volver antes (despertar espurio) sin error.

sync.Condition.waitUntilCopiar enlace

fn · línea 129

pub fn waitUntil(cond: *Condition, mutex: *Mutex, deadline: time.Deadline) TimedWaitError!void

Como wait, hasta el plazo monotónico deadline.

sync.Condition.signalCopiar enlace

fn · línea 156

pub fn signal(cond: *Condition) void

Despierta al menos a un hilo en espera.

sync.Condition.broadcastCopiar enlace

fn · línea 164

pub fn broadcast(cond: *Condition) void

Despierta a todos los hilos en espera.