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.