Mutexes (mutual-exclusion locks) are used to implement critical sections
and protect shared mutable data structures against concurrent accesses.
The typical use is (if
m is the mutex associated with the data structure
RMutex.synchronize ~lock:m (fun () -> (* Critical section that operates over D *); ) ()
This module implements reentrant mutexes, i.e. a version of mutexes which
may be locked again by their owner thread without blocking this thread.
Reentrant mutexes are typically slower than regular mutexes but also safer.
Author(s): Xavier Leroy (Base module), Damien Doligez (Base module), David Teller
val create :
unit -> t
val lock :
t -> unit
Note attempting to lock a mutex you already have locked from
the same thread will not suspend your thread.
val try_lock :
t -> bool
RMutex.lock, but does not suspend the calling thread if the mutex is already locked: just return
falseimmediately in that case. If the mutex is unlocked, lock it and return
val unlock :
t -> unit
val synchronize :
?lock:t -> ('a -> 'b) -> 'a -> 'b
synchronize f returns a new function
f' with the same behavior
f but such that concurrenty calls to
f' are queued if
necessary to avoid races.
synchronize ~lock:l f behaves as
synchronize f but uses a
l, which may be useful to share a lock
between several function.
In either case, the lock is acquired when entering the function
and released when the function call ends, whether this is due
to normal termination or to some exception being raised.
val make :
unit -> BatConcurrent.lock