Difference between binary semaphore and mutex

Question

Is there any difference between a binary semaphore and mutex or are they essentially the same?

Accepted Answer

They are NOT the same thing. They are used for different purposes! While both types of semaphores have a full/empty state and use the same API, their usage is very different.

Mutual Exclusion Semaphores Mutual Exclusion semaphores are used to protect shared resources (data structure, file, etc..).

A Mutex semaphore is "owned" by the task that takes it. If Task B attempts to semGive a mutex currently held by Task A, Task B's call will return an error and fail.

Mutexes always use the following sequence:

```
  - SemTake
  - Critical Section
  - SemGive
```

Here is a simple example:

```
  Thread A                     Thread B
   Take Mutex
     access data
     ...                        Take Mutex  <== Will block
     ...
   Give Mutex                     access data  <== Unblocks
                                  ...
                                Give Mutex
```

Binary Semaphore Binary Semaphore address a totally different question:

- Task B is pended waiting for something to happen (a sensor being tripped for example).

- Sensor Trips and an Interrupt Service Routine runs. It needs to notify a task of the trip.

- Task B should run and take appropriate actions for the sensor trip. Then go back to waiting.

```
   Task A                      Task B
   ...                         Take BinSemaphore   <== wait for something
   Do Something Noteworthy
   Give BinSemaphore           do something    <== unblocks
```

Note that with a binary semaphore, it is OK for B to take the semaphore and A to give it. Again, a binary semaphore is NOT protecting a resource from access. The act of Giving and Taking a semaphore are fundamentally decoupled. It typically makes little sense for the same task to call both give and take on the same binary semaphore.

Difference between binary semaphore and mutex

Solution

Problem

Related problems