Stdlib.Mutex(3) OCaml library Stdlib.Mutex(3)

# [NAME](#NAME)

Stdlib.Mutex - no description

# [Module](#Module)

Module Stdlib.Mutex

# [Documentation](#Documentation)

Module **Mutex**  
: **(module Stdlib\_\_Mutex)**

*type t*

The type of mutexes.

*val create* : **unit -> t**

Return a new mutex.

*val lock* : **t -> unit**

Lock the given mutex. Only one thread can have the mutex locked at any time. A thread that attempts to lock a mutex already locked by another thread will suspend until the other thread unlocks the mutex.

**Before4.12**

**Sys\_error** was not raised for recursive locking (platform-dependent behaviour)

**Raises Sys\_error** if the mutex is already locked by the thread calling **Mutex.lock** .

*val try\_lock* : **t -> bool**

Same as **Mutex.lock** , but does not suspend the calling thread if the mutex is already locked: just return **false** immediately in that case. If the mutex is unlocked, lock it and return **true** .

*val unlock* : **t -> unit**

Unlock the given mutex. Other threads suspended trying to lock the mutex will restart. The mutex must have been previously locked by the thread that calls **Mutex.unlock** .

**Before4.12**

**Sys\_error** was not raised when unlocking an unlocked mutex or when unlocking a mutex from a different thread.

**Raises Sys\_error** if the mutex is unlocked or was locked by another thread.

*val protect* : **t -> (unit -> 'a) -> 'a**

**protect mutex f** runs **f()** in a critical section where **mutex** is locked (using **Mutex.lock** ); it then takes care of releasing **mutex** , whether **f()** returned a value or raised an exception.

The unlocking operation is guaranteed to always takes place, even in the event an asynchronous exception (e.g. **Sys.Break** ) is raised in some signal handler.

**Since** 5.1

2026-10-01 OCamldoc

---

Document: Stdlib.Mutex(3o) from ocaml 5.5.1-r1 (Chainguard OS)
Source: https://github.com/ocaml/ocaml