mutex(SYNCH)
mutex: mutex_init, mutex_lock, mutex_trylock, mutex_unlock, mutex_destroy --
overview of mutual exclusion lock routines
Synopsis
cc [options] -Kthread file
#include <synch.h>
int mutex_init(mutex_t *mutex, int type, void *arg);
int mutex_lock(mutex_t *mutex);
int mutex_trylock(mutex_t *mutex);
int mutex_unlock(mutex_t *mutex);
int mutex_destroy(mutex_t *mutex);
Description
Mutual exclusion locks, or ``mutexes'',
are used to serialize the execution of threads.
They are typically used to ensure
that only one thread at a time accesses shared data.
Note that mutexes protect data only when the convention
of acquiring the mutex is faithfully followed before any access
of the data.
The Threads Library provides five routines
to manipulate mutexes;
these are outlined below
and described in more detail on individual manual pages.
Parameters
mutex-
pointer to mutex to be initialized, locked, unlocked, or destroyed
type-
USYNC_THREAD or USYNC_PROCESS
arg-
NULL (reserved for future use)
mutex_init(3synch)
mutex_init initializes a mutex
to be of type type and in the unlocked state.
mutex_lock(3synch)
mutex_lock locks
the mutex pointed to by mutex.
If mutex is already locked,
the calling thread is blocked until mutex becomes available.
When mutex_lock returns successfully,
the caller has locked mutex.
mutex_trylock(3synch)
mutex_trylock attempts once to lock the
mutex pointed to by mutex.
If mutex is available,
mutex_trylock will return successfully
with mutex locked.
If mutex is already locked,
mutex_trylock immediately returns EBUSY to the caller
without acquiring mutex or blocking.
mutex_unlock(3synch)
mutex_unlock unlocks the mutex pointed to by mutex.
If there are one or more threads waiting for mutex when
mutex_unlock is called,
at least one waiting thread is
allowed to try again to lock mutex.
mutex_destroy(3synch)
mutex_destroy destroys the mutex pointed to by mutex.
This includes invalidating mutex and freeing any
associated implementation-allocated dynamic resources.
USYNC_THREAD and USYNC_PROCESS mutexes
Mutexes are initialized to be one of two types:
USYNC_THREAD or USYNC_PROCESS.
USYNC_THREAD mutexes are available
only to threads within the current process.
USYNC_PROCESS mutexes can be used by threads
in different processes.
General information
Mutexes must be initialized,
either with
mutex_init(SYNCH)
or statically (see mutex_init),
before being passed to any of the other mutex routines.
Locks acquired with mutex_lock or mutex_trylock
must be released with mutex_unlock.
From the point of view of the caller,
mutex_lock is atomic:
even if interrupted by a signal or forkall
(see
fork(S)),
mutex_lock will not return until it holds the locked mutex.
As a consequence, if mutex_lock is interrupted,
an error indication such as EINTR is never returned to the caller.
Warnings
Operations on mutexes
are not recursive--a thread can deadlock if
it attempts to relock a mutex that it already has locked.
If a thread exits while holding a mutex,
the mutex will not be unlocked,
and other threads waiting for the mutex will wait forever.
Similarly, if a process exits while holding a USYNC_PROCESS mutex,
the mutex will not be unlocked,
and other processes or threads waiting for the mutex will wait forever.
References
fork(S),
Intro(SYNCH),
mutex_init(SYNCH),
mutex_destroy(SYNCH),
mutex_lock(SYNCH),
mutex_trylock(SYNCH),
mutex_unlock(SYNCH),
rmutex(SYNCH)
© 2005 The SCO Group, Inc. All rights reserved.
SCO OpenServer Release 6.0.0 - 01 June 2005