互斥对象有所有权，不像信号量。尽管在互斥量范围内的任何线程都可以获得一个未锁定的互斥量，并锁定对同一关键代码段的访问，但只有锁定了互斥量的线程才应该解锁它。

它们的同步语义非常不同:

互斥对象允许对给定资源的序列化访问，即多个线程等待一个锁，一次一个，正如前面所说，线程拥有锁，直到锁完成:只有这个特定的线程可以解锁它。 二进制信号量是一个值为0和1的计数器:任务阻塞在它上，直到任何任务执行sem_post。信号量宣布资源可用，并提供等待机制，直到发出可用信号。

因此，可以将互斥锁视为在任务之间传递的令牌，将信号量视为交通红灯(它向某人发出信号，表示可以继续进行)。

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.

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

答案可能取决于目标操作系统。例如，我所熟悉的至少一个RTOS实现允许对单个OS互斥量进行多个连续的“get”操作，只要它们都来自同一个线程上下文中。在允许另一个线程获得互斥量之前，多个get必须被相等数量的put替换。这与二进制信号量不同，对于二进制信号量，无论线程上下文如何，一次只允许一个get。

这种互斥锁背后的思想是，通过一次只允许一个上下文修改数据来保护对象。即使线程获得了互斥量，然后调用进一步修改对象的函数(并在自己的操作周围获得/放置保护互斥量)，这些操作仍然应该是安全的，因为它们都发生在单个线程下。

{
    mutexGet();  // Other threads can no longer get the mutex.

    // Make changes to the protected object.
    // ...

    objectModify();  // Also gets/puts the mutex.  Only allowed from this thread context.

    // Make more changes to the protected object.
    // ...

    mutexPut();  // Finally allows other threads to get the mutex.
}

当然，在使用此特性时，必须确保单个线程中的所有访问都是安全的!

我不确定这种方法有多普遍，或者它是否适用于我所熟悉的系统之外。有关这种互斥锁的示例，请参阅ThreadX RTOS。

互斥锁用于“锁定机制”。每次只有一个进程可以使用共享资源

而

信号量用于“信号机制” 比如“我完成了，现在可以继续了”

除了互斥对象有一个所有者之外，这两个对象还可以针对不同的用途进行优化。互斥锁被设计为只保留很短的时间;违反这一点会导致糟糕的性能和不公平的调度。例如，一个正在运行的线程可能被允许获取一个互斥量，即使另一个线程已经被阻塞在这个线程上。信号量可以提供更多的公平性，或者可以使用几个条件变量强制实现公平性。