A synchronization object used for interprocess communication. A mutex can be owned by at most one thread at any one time, or it can be owned by none. A mutex is in a signaled state when it is unowned by a thread, and in a nonsignaled state when it is owned. Back
The word mutex is shorthand for a primitive object that provides MUTual EXclusion between threads. A mutual exclusion (mutex) is used cooperatively between threads to ensure that only one of the cooperating threads is allowed to access the data or run certain application code at a time.
A mutex (which stands for "mutual exclusion" is a pthreads object that facilitates fine-grained parallelism. Mutexes are in one of two states: locked and unlocked. A mutex can be locked by one thread at most -- attempting to lock a previously locked mutex causes the calling thread to block.
a data type that represents sections of code or allocated memory that only one thread can access, restricting all others
a kernel object that can be used to synchronize threads running is different processes
a locking mechanism to ensure the mutually exclusive use of shared data and critical sections of code
a lock that is held by a single thread
a MUTual EXclusion device, and is useful for protecting shared data structures from concurrent modifications, and implementing critical sections and monitors
a "mutual exclusion" variable associated with hardware that can be atomically locked and unlocked
a mutually exclusive entity that functions across application boundaries
a "mutually exclusive" lock
a named synchronization object derived from the WaitHandle class that allows for creation of mutually exclusive regions of code
an object used for mutual exclusion of a shared resource
an object wich can only be "owned" or locked by one thread at a time, so it is used to protect shared resources
an OS-level synchronisation primitive that can be used to ensure a section of code can only be executed by one thread at a time
a program object that allows multiple threads to share a resource, such as file access, but not simultaneously
a resource of the process, not part of any particular thread
a semaphore object that prevents multiple threads from accessing a resource concurrently
a synchronization function that is used to allow multiple jobs or threads to serialize their access to shared data
a synchronization mechanism (similar to a Lock, i
a synchronization object that allows multiple threads to serialize their access to shared data
a synchronization object that allows one thread mutually exclusive access to a resource
a synchronization object that allows only one process or thread to access a critical code block
a synchronization object that can also be used globally by specifying a name
a synchronization object used to ensure that only one thread can be executed in a particular section of code or access a particular portion of memory at a single time
mutual exclusion object that allows multiple threads to synchronize access to shared resources. A mutex has two states: locked and unlocked. Once a mutex has been locked by a thread, other threads attempting to lock it will block. When the locking thread unlocks (releases) the mutex, one of the blocked threads will lock (acquire) it and proceed with its execution. A mutex is thus a binary semaphore.
Mutual exclusion lock, a simple synchronization service used to ensure exclusive access to data shared between threads. It is typically acquired ( pthread_mutex_lock()) and released ( pthread_mutex_unlock()) around the code that accesses the shared data (usually a critical section). See also critical section.
Sleep locks provided in the form of mutual exclusion locks. These are data structures allocated in the client actors' address spaces.
MUTual EXclusion mechanism, a means for inter-task communication usually provided by the operating system. Concurrent tasks use a mutex to ensure that only one task can access a shared resource. Any other task trying to get the mutex will either be blocked (suspended) until the mutex is released, or its request will be rejected.
MUT ual EX clusion locks. This locking primitive is simpler and semantically tighter than the others, and hence is easier to make faster, and to prove correct. Some constraints are; lock has one owner at a time, the locker, who must also be the unlocker. Read Documentation/mutex-design.txt for much more.
An abstraction that allows two or more threads to co-operate in a MUTual EXclusion protocol that allows safe access to a shared resources. See pthread_mutex_init() or other functions whose names begin with `pthread_mutex_'. Also see `Recursive Mutex', `Named Mutex', `Global Mutex'.
Meaning mutual exclusion, an object that multiple threads use to ensure the integrity of a shared resource that they access (most commonly shared data) by allowing only one thread to access it at a time. See also fast mutex, nonrecursive mutex, and recursive mutex.
(mew tex) An operating system data structure used by tasks to ensure exclusive access to shared variables or hardware registers. Short for mutual exclusion. A mutex is a multitasking-aware binary flag that can be used to synchronize the activities of multiple tasks. As such, it can protect critical sections from interruption and shared resources from simultaneous accesses. USAGE: The term "mutex" is best reserved only for binary semaphores that are aware of the potential for priority inversions and implement an appropriate workaround. But beware that many RTOS vendors do not make such distinctions.
Jargon for mutual exclusion lock. Use of this type of lock excludes all threads other than the lock holder from any access whatsoever to the locked resource.
