Mutex uses a locking mechanism i.e. if a process wants to use a resource then it locks the resource, uses it and then release it. But on the other hand, semaphore uses a signalling mechanism where wait() and signal() methods are used to show if a process is releasing a resource or taking a resource. A mutex is an object but semaphore is an integer variable. In semaphore, we have wait() and signal() functions. But in mutex, there is no such function. A mutex object allows multiple process threads to access a single shared resource but only one at a time. On the other hand, semaphore allows multiple process threads to access the finite instance of the resource until available. In mutex, the lock can be acquired and released by the same process at a time. But the value of the semaphore variable can be modified by any process that needs some resource but only one process can change the value at a time.

一本有用的书，我从这里学习和复制

互斥量和二进制信号量是相同的用法，但实际上，它们是不同的。

对于互斥锁，只有锁定了它的线程才能解锁它。如果有其他线程来锁定它，它将等待。

对于信号电话来说，情况就不是这样了。信号量没有与特定的线程ID绑定。

既然上面的答案都不能消除困惑，这里有一个答案可以消除我的困惑。

Strictly speaking, a mutex is a locking mechanism used to synchronize access to a resource. Only one task (can be a thread or process based on OS abstraction) can acquire the mutex. It means there will be ownership associated with mutex, and only the owner can release the lock (mutex). Semaphore is signaling mechanism (“I am done, you can carry on” kind of signal). For example, if you are listening songs (assume it as one task) on your mobile and at the same time your friend called you, an interrupt will be triggered upon which an interrupt service routine (ISR) will signal the call processing task to wakeup.

来源:http://www.geeksforgeeks.org/mutex-vs-semaphore/

互斥锁控制对单个共享资源的访问。它提供了获取()对资源的访问并在完成后释放()资源的操作。

信号量控制对共享资源池的访问。它提供Wait()操作，直到池中的一个资源可用，并提供Signal()操作，当它返回池时。

当一个信号量保护的资源数量大于1时，它被称为计数信号量。当它控制一个资源时，它被称为布尔信号量。布尔信号量相当于互斥量。

因此，信号量是比互斥量更高级别的抽象。互斥锁可以用信号量来实现，但不能用信号量来实现。

互斥量是任何想要解决临界区问题的算法都必须遵循的标准，而二进制信号量本身是一个可以取0和1值的变量。

I think most of the answers here were confusing especially those saying that mutex can be released only by the process that holds it but semaphore can be signaled by ay process. The above line is kind of vague in terms of semaphore. To understand we should know that there are two kinds of semaphore one is called counting semaphore and the other is called a binary semaphore. In counting semaphore handles access to n number of resources where n can be defined before the use. Each semaphore has a count variable, which keeps the count of the number of resources in use, initially, it is set to n. Each process that wishes to uses a resource performs a wait() operation on the semaphore (thereby decrementing the count). When a process releases a resource, it performs a release() operation (incrementing the count). When the count becomes 0, all the resources are being used. After that, the process waits until the count becomes more than 0. Now here is the catch only the process that holds the resource can increase the count no other process can increase the count only the processes holding a resource can increase the count and the process waiting for the semaphore again checks and when it sees the resource available it decreases the count again. So in terms of binary semaphore, only the process holding the semaphore can increase the count, and count remains zero until it stops using the semaphore and increases the count and other process gets the chance to access the semaphore.

二进制信号量和互斥量之间的主要区别在于，信号量是一种信号机制，而互斥量是一种锁定机制，但二进制信号量的功能似乎与互斥量类似，这造成了混乱，但两者是适用于不同类型工作的不同概念。