When should we use mutex and when should we use semaphore

Question

User · Answer

A mutex is a mutual exclusion object  similar to a semaphore but that only allows one locker at a time and whose ownership restrictions may be more stringent than a semaphore   It can be thought of as equivalent to a normal counting semaphore  with a count of one  and the requirement that it can only be released by the same thread that locked it a    A semaphore  on the other hand  has an arbitrary count and can be locked by that many lockers concurrently  And it may not have a requirement that it be released by the same thread that claimed it  but  if not  you have to carefully track who currently has responsibility for it  much like allocated memory    So  if you have a number of instances of a resource  say three tape drives   you could use a semaphore with a count of 3  Note that this doesn t tell you which of those tape drives you have  just that you have a certain number   Also with semaphores  it s possible for a single locker to lock multiple instances of a resource  such as for a tape-to-tape copy  If you have one resource  say a memory location that you don t want to corrupt   a mutex is more suitable   Equivalent operations are   Counting semaphore          Mutual exclusion semaphore --------------------------  --------------------------   Claim decrease  P                   Lock   Release increase  V                 Unlock   Aside  in case you ve ever wondered at the bizarre letters used for claiming and releasing semaphores  it s because the inventor was Dutch  Probeer te verlagen means to try and decrease while verhogen means to increase      a      or it can be thought of as something totally distinct from a semaphore  which may be safer given their almost-always-different uses

User · Answer

Mutex is to protect the shared resource  Semaphore is to dispatch the threads   Mutex  Imagine that there are some tickets to sell  We can simulate a case where many people buy the tickets at the same time  each person is a thread to buy tickets  Obviously we need to use the mutex to protect the tickets because it is the shared resource    Semaphore  Imagine that we need to do a calculation as below   c   a   b    Also  we need a function geta   to calculate a  a function getb   to calculate b and a function getc   to do the calculation c   a   b   Obviously  we can t do the c   a   b unless geta   and getb   have been finished  If the three functions are three threads  we need to dispatch the three threads   int a  b  c  void geta         a   calculatea        semaphore increase       void getb         b   calculateb        semaphore increase       void getc         semaphore decrease        semaphore decrease        c   a   b     t1   thread create geta   t2   thread create getb   t3   thread create getc   thread join t3     With the help of the semaphore  the code above can make sure that t3 won t do its job untill t1 and t2 have done their jobs   In a word  semaphore is to make threads execute as a logicial order whereas mutex is to protect shared resource  So they are NOT the same thing even if some people always say that mutex is a special semaphore with the initial value 1  You can say like this too but please notice that they are used in different cases  Don t replace one by the other even if you can do that

User · Answer

Trying not to sound zany  but can t help myself   Your question should be what is the difference between mutex and semaphores   And to be more precise question should be   what is the relationship between mutex and semaphores      I would have added that question but I m hundred   sure some overzealous moderator would close it as duplicate without understanding difference between difference and relationship    In object terminology we can observe that    observation 1 Semaphore contains mutex  observation 2 Mutex is not semaphore and semaphore is not mutex    There are some semaphores that will act as if they are mutex  called binary semaphores  but they are freaking NOT mutex   There is a special ingredient called Signalling  posix uses condition variable for that name   required to make a Semaphore out of mutex  Think of it as a notification-source   If two or more threads are subscribed to same notification-source  then it is possible to send them message to either ONE or to ALL  to wakeup   There could be one or more counters associated with semaphores  which are guarded by mutex  The simple most scenario for semaphore  there is a single counter which can be either 0 or 1   This is where confusion pours in like monsoon rain   A semaphore with a counter that can be 0 or 1 is NOT mutex   Mutex has two states  0 1  and one ownership task    Semaphore has a mutex  some counters and a condition variable   Now  use your imagination  and every combination of usage of counter and when to signal can make one kind-of-Semaphore    Single counter with value 0 or 1 and signaling when value goes to 1 AND then unlocks one of the guy waiting on the signal    Binary semaphore Single counter with value 0 to N and signaling when value goes to less than N  and locks waits when values is N    Counting semaphore  Single counter with value 0 to N and signaling when value goes to N  and locks waits when values is less than N    Barrier semaphore  well if they dont call it  then they should     Now to your question  when to use what   OR rather correct question version 3  when to use mutex and when to use binary-semaphore  since there is no comparison to non-binary-semaphore   Use mutex when  1  you want a customized behavior  that is not provided by binary semaphore  such are spin-lock or fast-lock or recursive-locks  You can usually customize mutexes with attributes  but customizing semaphore is nothing but writing new semaphore  2  you want lightweight OR faster primitive  Use semaphores  when what you want is exactly provided by it    If you dont understand what is being provided by your implementation of binary-semaphore  then IMHO  use mutex   And lastly read a book rather than relying just on SO

User · Answer

I think the question should be the difference between mutex and binary semaphore   Mutex    It is a ownership lock mechanism  only the thread who acquire the lock can release the lock   binary Semaphore    It is more of a signal mechanism  any other higher priority thread if want can signal and take the lock

User · Answer

Binary semaphore and Mutex are different  From OS perspective  a binary semaphore and counting semaphore are implemented in the same way and a binary semaphore can have a value 0 or 1   Mutex -  Can only be used for one and only purpose of mutual exclusion for a critical section of code   Semaphore -  Can be used to solve variety of problems  A binary semaphore can be used for signalling and also solve mutual exclusion problem  When initialized to 0  it solves signalling problem and when initialized to 1  it solves mutual exclusion problem   When the number of resources are more and needs to be synchronized  we can use counting semaphore   In my blog  I have discussed these topics in detail   https   designpatterns-oo-cplusplus blogspot com 2015 07 synchronization-primitives-mutex-and html

User · Answer

It is very important to understand that a mutex is not a semaphore with count 1   This is the reason there are things like binary semaphores  which are really semaphores with count 1    The difference between a Mutex and a Binary-Semaphore is the principle of ownership   A mutex is acquired by a task and therefore must also be released by the same task  This makes it possible to fix several problems with binary semaphores  Accidential release  recursive deadlock and priority inversion    Caveat  I wrote  makes it possible   if and how these problems are fixed is up to the OS implementation   Because the mutex is has to be released by the same task it is not very good for synchronization of tasks   But if combined with condition variables you get very powerful building blocks for building all kinds of ipc primitives   So my recommendation is  if you got cleanly implemented mutexes and condition variables  like with POSIX pthreads  use these   Use semaphores only if they fit exactly to the problem you are trying to solve  don t try to build other primitives  e g  rw-locks out of semaphores  use mutexes and condition variables for these   There is a lot of misunderstanding mutexes and semaphores   The best explanation I found so far is in this 3-Part article   Mutex vs  Semaphores     Part 1  Semaphores  Mutex vs  Semaphores     Part 2  The Mutex  Mutex vs  Semaphores     Part 3  final part   Mutual Exclusion Problems

User · Answer

While  opaxdiablo answer is totally correct I would like to point out that the usage scenario of both things is quite different  The mutex is used for protecting parts of code from running concurrently  semaphores are used for one thread to signal another thread to run       Task 1    pthread mutex lock mutex thing          Safely use shared resource pthread mutex unlock mutex thing         Task 2    pthread mutex lock mutex thing         Safely use shared resource pthread mutex unlock mutex thing      unlock mutex   The semaphore scenario is different      Task 1 - Producer    sema post  amp sem        Send the signal     Task 2 - Consumer    sema wait  amp sem        Wait for signal   See http   www netrino com node 202 for further explanations

User · Answer

All the above answers are of good quality but this one s just to memorize The name Mutex is derived from Mutually Exclusive hence you are motivated to think of a mutex lock as Mutual Exclusion between two as in only one at a time and if I possessed it you can have it only after I release it On the other hand such case doesn t exist for Semaphore is just like  a traffic signal which the word Semaphore also means

User · Answer

As was pointed out  a semaphore with a count of one is the same thing as a  binary  semaphore which is the same thing as a mutex   The main things I ve seen semaphores with a count greater than one used for is producer consumer situations in which you have a queue of a certain fixed size   You have two semaphores then   The first semaphore is initially set to be the number of items in the queue and the second semaphore is set to 0   The producer does a P operation on the first semaphore  adds to the queue  and does a V operation on the second   The consumer does a P operation on the second semaphore  removes from the queue  and then does a V operation on the first   In this way the producer is blocked whenever it fills the queue  and the consumer is blocked whenever the queue is empty

User · Answer

Here is how I remember when to use what -   Semaphore  Use a semaphore when you  thread  want to sleep till some other thread tells you to wake up  Semaphore  down  happens in one thread  producer  and semaphore  up   for same semaphore  happens in another thread  consumer  e g   In producer-consumer problem  producer wants to sleep till at least one buffer slot is empty - only the consumer thread can tell when a buffer slot is empty    Mutex  Use a mutex when you  thread  want to execute code that should not be executed by any other thread at the same time  Mutex  down  happens in one thread and mutex  up  must happen in the same thread later on  e g   If you are deleting a node from a global linked list  you do not want another thread to muck around with pointers while you are deleting the node  When you acquire a mutex and are busy deleting a node  if another thread tries to acquire the same mutex  it will be put to sleep till you release the mutex   Spinlock  Use a spinlock when you really want to use a mutex but your thread is not allowed to sleep   e g   An interrupt handler within OS kernel must never sleep  If it does the system will freeze   crash  If you need to insert a node to globally shared linked list from the interrupt handler  acquire a spinlock - insert node - release spinlock

User · Answer

See  The Toilet Example  - http   pheatt emporia edu courses 2010 cs557f10 hand07 Mutex 20vs  20Semaphore htm   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   Ref  Symbian Developer Library   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

User · Answer

A mutex is a special case of a semaphore  A semaphore allows several threads to go into the critical section  When creating a semaphore you define how may threads are allowed in the critical section  Of course your code must be able to handle several accesses to this critical section

[linux] When should we use mutex and when should we use semaphore

Examples related to linux

Examples related to multithreading

Examples related to synchronization

Examples related to mutex

Examples related to semaphore