Mutex can be released only by thread that had acquired it,
while you can signal semaphore from any other thread (or process), so
semaphores are more suitable for some synchronization problems like
producer-consumer.
On
Windows, binary semaphores are more like event objects than mutexes.
Mutex:
Is a key to a toilet. One person can
have the key - occupy the toilet - at the time. When finished, the person gives
(frees) the key to the next person in the queue.
Officially: "Mutexes are typically used to serialise
access to a section of re-entrant code that cannot be executed concurrently by
more than one thread. A mutex object only allows one thread into a controlled
section, forcing other threads which attempt to gain access to that section to
wait until the first thread has exited from that section."
(A mutex is really a semaphore with value 1.)
Semaphore:
Is the number of free identical toilet
keys. Example, say we have four toilets with identical locks and keys. The semaphore
count - the count of keys - is set to 4 at beginning (all four toilets are
free), then the count value is decremented as people are coming in. If all
toilets are full, ie. there are no free keys left, the semaphore count is 0.
Now, when eq. one person leaves the toilet, semaphore is increased to 1 (one
free key), and given to the next person in the queue.
Officially: "A semaphore restricts the number of
simultaneous users of a shared resource up to a maximum number. Threads can
request access to the resource (decrementing the semaphore), and can signal
that they have finished using the resource (incrementing the semaphore)."
Ref: Symbian Developer Library
Their synchronization semantics are very different:
·
mutexes allow serialization of access to a given resource i.e.
multiple threads wait for a lock, one at a time and as previously said, the
thread owns the lock until it is done: only this
particular thread can unlock it.
·
a binary semaphore is a counter with value 0 and 1: a task
blocking on it until any task does a sem_post. The semaphore
advertises that a resource is available, and it provides the mechanism to wait
until it is signaled as being available.
As such one can see a mutex as a token
passed from task to tasks and a semaphore as traffic red-light (it signals someone
that it can proceed).
On
Windows, there are two differences between mutexes and binary semaphores:
1. A mutex can only be released by the thread which has
ownership, i.e. the thread which previously called the Wait function, (or which
took ownership when creating it). A semaphore can be released by any thread.
2. A thread can call a wait function repeatedly on a mutex
without blocking. However, if you call a wait function twice on a binary
semaphore without releasing the semaphore in between, the thread will block.
for more details :
No comments:
Post a Comment