How to distinguish the Semaphore synchronization mechanism from Mutual Exclusion (Mutex)?

Semaphore and Mutex are synchronization mechanisms, but they have different purposes and behaviors:

• Mutex (mutual exclusion) is designed to protect access to a resource that can only be used by one thread at a time. Mutex guarantees that at any given moment, only one owner has the resource. Typically, a mutex has two states: locked and unlocked.

• Semaphore is a more general mechanism that manages a counter, allowing to limit the number of threads that can access a resource simultaneously. For example, a semaphore with a counter of 3 allows three threads to work with the resource at the same time.

Main difference:

• Mutex is binary (0 or 1), used for mutual exclusion.
• Semaphore is a counter, which can be greater than 1, used to limit the number of concurrent accesses.

Example in iOS (Swift) using DispatchSemaphore:

let semaphore = DispatchSemaphore(value: 2) // maximum 2 threads at the same time

func accessResource() {
    semaphore.wait() // decrease the counter, if 0 — thread blocks
    // Work with the resource
    print("Thread has access")
    semaphore.signal() // increase the counter, free up space
}

Mutex in iOS is usually implemented via NSLock or pthread_mutex_t and guarantees that only one thread executes the critical section.