This document describes how to use mutexes.
Mutexes provide serialised access to shared resources. They are Kernel objects and, as such, are managed by the Kernel.
A mutex can be used by threads across any number of processes. If a resource is only shared between the threads within the same process, it can be more efficient to use a critical section.
Access to a mutex is through an RMutex handle.
Mutexes are similar to semaphores in that they have a TInt count
value that is incremented by calling the Signal() member
function of the mutex handle and decremented by calling the Wait() member
function of the mutex handle. A mutex with a negative value implies that a
thread must wait for access to the shared resource.
Unlike a semaphore, the count value of a mutex is always set to one when it is constructed.
The creator of a shared resource uses the CreateLocal() or CreateGlobal() member
functions of RMutex to create a mutex and to open the handle
to it. Any thread wishing to access the resource first calls Wait();
that thread then calls Signal() after completing its access.
The first thread to call Wait() returns immediately, and
is free to continue execution, but any other threads that call Wait() will
wait in a queue maintained by the mutex. Waiting threads are released on a
first-in first-out basis when the thread currently accessing the resource
calls Signal().
The nature of the shared resources should be such that any access completes in a relatively short time so that threads do not wait for extensive periods on the mutex.
In many cases, it may be better to use servers to serialize access to a shared resource (for example, the window server) rather than use a mutex.