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

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

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

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

虽然二进制信号量可以用作互斥量，但互斥量是一个更具体的用例，因为只有锁定了互斥量的进程才应该解锁它。这种所有权限制使我们有可能对以下情况提供保护:

意外释放 递归死锁 任务死亡死锁

这些限制并不总是存在，因为它们降低了速度。在代码开发期间，您可以暂时启用这些检查。

例如，你可以在互斥锁中启用错误检查属性。错误检查互斥量返回EDEADLK，如果你试图锁定同一个互斥量两次，如果你解锁了一个不是你的互斥量，返回EPERM。

pthread_mutex_t mutex;
pthread_mutexattr_t attr;
pthread_mutexattr_init (&attr);
pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_ERRORCHECK_NP);
pthread_mutex_init (&mutex, &attr);

一旦初始化，我们可以将这些检查放在我们的代码中，就像这样:

if(pthread_mutex_unlock(&mutex)==EPERM)
 printf("Unlock failed:Mutex not owned by this thread\n");

二进制信号量和互斥量的区别: 所有权: 信号量甚至可以从非当前所有者发出信号(发布)。这意味着您可以简单地从任何其他线程发布，尽管您不是所有者。

信号量是进程中的公共属性，它可以简单地由非所有者线程发布。 请用粗体字标出这个区别，这意味着很多。

互斥锁:假设我们有临界区线程T1想要访问它，然后按照以下步骤进行。 T1:

锁 使用临界区 解锁

二进制信号量:它基于信号等待和信号工作。 等待将“s”的值减少1，通常“s”的值初始化为值“1”， 信号(s)使“s”值加1。如果“s”值为1表示没有人在使用临界区，当“s”值为0时表示临界区正在使用。 假设线程T2正在使用临界区，那么它遵循以下步骤。 T2:

Wait (s)//最初的s值是1，调用Wait后，它的值减少了1，即0 利用临界区 信号(s) //现在s值增加，变成1

Main difference between Mutex and Binary semaphore is in Mutext if thread lock the critical section then it has to unlock critical section no other thread can unlock it, but in case of Binary semaphore if one thread locks critical section using wait(s) function then value of s become "0" and no one can access it until value of "s" become 1 but suppose some other thread calls signal(s) then value of "s" become 1 and it allows other function to use critical section. hence in Binary semaphore thread doesn't have ownership.

You obviously use mutex to lock a data in one thread getting accessed by another thread at the same time. Assume that you have just called lock() and in the process of accessing data. This means that you don’t expect any other thread (or another instance of the same thread-code) to access the same data locked by the same mutex. That is, if it is the same thread-code getting executed on a different thread instance, hits the lock, then the lock() should block the control flow there. This applies to a thread that uses a different thread-code, which is also accessing the same data and which is also locked by the same mutex. In this case, you are still in the process of accessing the data and you may take, say, another 15 secs to reach the mutex unlock (so that the other thread that is getting blocked in mutex lock would unblock and would allow the control to access the data). Do you at any cost allow yet another thread to just unlock the same mutex, and in turn, allow the thread that is already waiting (blocking) in the mutex lock to unblock and access the data? Hope you got what I am saying here? As per, agreed upon universal definition!,

使用“互斥”就不会发生这种情况。没有其他线程可以解锁锁 在你的帖子里 使用“二进制信号量”可以实现这种情况。任何其他线程都可以解锁 线程中的锁

因此，如果您非常注重使用二进制信号量而不是互斥量，那么在锁定和解锁的“作用域”时应该非常小心。我的意思是，每个触及每个锁的控制流都应该触及一个解锁调用，也不应该有任何“第一次解锁”，而应该总是“第一次锁定”。

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

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

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