# Module Std.Mutex

    module Mutex: Core_mutex

    type t = Mutex.t

    val create : unit -> t

    val equal : t -> t -> bool

    val lock : t -> unit

`lock mtx` locks `mtx`, possibly waiting for it to be released first by another thread.
Raises `Unix_error` if `lock` attempts to acquire `mtx` recursively.

    val try_lock : t -> [ `Acquired | `Already_held_by_me_or_other ]

`try_lock` is like `lock`, but always returns immediately. If the calling thread or another one already has the mutex it returns ``Already_held_by_me_or_other`, otherwise it locks it and returns ``Acquired`.

    val timedlock : (t -> Time.t -> bool) Core_kernel.Std.Or_error.t

`timedlock mtx timeout` like `lock`, but takes a `timeout` parameter.
Raises `Unix_error` if `timedlock` attempts to acquire `mtx` recursively.
Returns `true` if the mutex was acquired, or `false` when `timeout` expires otherwise.

    val unlock : t -> unit

`unlock mtx` unlocks `mtx`.
Raises `Unix_error` if `unlock` attempts to release an unacquired mutex or a mutex held by another thread.

    val critical_section : t -> f:(unit -> 'a) -> 'a

    val synchronize : ('a -> 'b) -> 'a -> 'b

`synchronize f` creates a mutex and returns a new function that is identical to `f` except that the mutex is held during its execution.

    val update_signal : t -> Condition.t -> f:(unit -> 'a) -> 'a

`update_signal mtx cnd ~f` updates some state within a critical section protected by mutex `mtx` using function `f` and signals condition variable `cnd` after finishing. If `f` raises an exception, the condition will NOT be signaled!

    val update_broadcast : t -> Condition.t -> f:(unit -> 'a) -> 'a

`update_broadcast mtx cnd ~f` updates some state within a critical section protected by mutex `mtx` using function `f` and broadcasts condition variable `cnd` after finishing. If `f` raises an exception, the condition will NOT be broadcast!