it-swarm.cn

二进制信号量和互斥量之间的区别

二进制信号量和互斥量之间是否存在差异,或它们基本相同?

741
Nitin

它们是 _不_ 同样的事情。它们用于不同的目的!
虽然两种类型的信号量都具有完整/空状态并使用相同的API,但它们的使用方式却截然不同。

相互排除信号量
互斥信号量用于保护共享资源(数据结构,文件等)。

Mutex信号量由接受它的任务“拥有”。如果任务B尝试semGive当前由任务A持有的互斥锁,则任务B的调用将返回错误并失败。

互斥锁始终使用以下顺序:

  -  SemTake 
  - 关键部分
  -  SemGive

这是一个简单的例子:

线程A线程B 
获取互斥
访问数据
 ...取Mutex <==将阻止
 ...... 
给Mutex访问数据<== Unblocks 
 ... 
给Mutex 

二进制信号量
Binary Semaphore解决了一个完全不同的问题:

  • 任务B等待发生某事(例如传感器被绊倒)。
  • 传感器跳闸和中断服务程序运行。它需要通知行程的任务。
  • 任务B应该运行并对传感器跳闸采取适当的措施。然后回去等。

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

请注意,对于二进制信号量,B可以使用信号量和A来提供它。
同样,二进制信号量不保护资源不被访问。给予和获取信号量的行为从根本上是分离的。
对于相同的任务来说,通常对同一个二进制信号量的给予和接受没有多大意义。

635
Benoit

厕所的例子 是一个令人愉快的比喻:

互斥:

是厕所的关键。一个人可以拥有钥匙 - 占用厕所 - 当时。完成后,该人员将(释放)密钥提供给队列中的下一个人。

正式说:“互斥锁通常用于序列化对一部分重入代码的访问,这些代码不能由多个线程同时执行。互斥对象只允许一个线程进入受控部分,强制其他线程尝试访问该部分要等到第一个线程退出该部分。“参考:Symbian开发人员库

(互斥体实际上是一个值为1的信号量。)

信号:

是免费相同的厕所钥匙的数量。例如,我们说有四个带有相同锁和钥匙的马桶。信号量计数 - 键数 - 在开始时设置为4(所有四个厕所都是免费的),然后计数值随着人们的进入而减少。如果所有厕所都已满,即。没有剩余的自由键,信号量计数为0.现在,当eq。一个人离开厕所,信号量增加到1(一个自由键),并给予队列中的下一个人。

正式地说:“信号量将共享资源的同时用户数量限制为最大数量。线程可以请求访问资源(递减信号量),并且可以发信号通知他们已经完成了使用资源(递增信号量)。 “参考:Symbian开发人员库

416
dlinsin

Mutex只能由获取它的线程释放,而您可以从任何其他线程(或进程)发出信号量信号,因此信号量更适合某些同步问题,如producer-consumer。

在Windows上,二进制信号量更像是事件对象而不是互斥体。

411
Mladen Janković

关于这个主题的好文章:

从第2部分开始: /

互斥体类似于二进制信号量的原理,有一个显着的区别:所有权原则。所有权是一个简单的概念,当任务锁定(获取)互斥锁时,它只能解锁(释放)它。如果任务尝试解锁互斥锁,它未锁定(因此不拥有),则会遇到错误情况,最重要的是,互斥锁未解锁。如果互斥对象没有所有权,那么与它所称的无关,它不是互斥体。

139
teki

由于上述答案都没有解决这个混乱,所以这里有一个让我感到困惑的答案。

严格来说, 互斥锁是一种锁定机制 用于同步对资源的访问。只有一个任务(可以是基于操作系统抽象的线程或进程)可以获取互斥锁。这意味着将拥有与互斥锁相关联的所有权,只有所有者才能释放锁(互斥锁)。

信号量是信令机制 (“我做完了,你可以继续”那种信号)。例如,如果您正在移动设备上监听歌曲(假设它是一项任务),同时您的朋友打电话给您,则会触发中断,中断服务程序(ISR)将通知呼叫处理任务唤醒。

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

92
Hemant

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

  • 互斥体允许序列化对给定资源的访问,即多个线程等待锁定,一次一个,如前所述,线程 拥有 锁定,直到完成: only 此特定线程可以解锁它。
  • 二进制信号量是一个值为0和1的计数器:一个任务阻塞它,直到 任何 task执行sem_post。信号量通告资源可用,并提供等待信号可用的机制。

因此,可以看到互斥体作为从任务传递到任务的令牌和信号量作为流量红灯(它 信号 它可以继续的某个人)。

37
ppi
  • 根据定义,A Mutex 用于序列化对一部分可重入代码的访问,这些代码不能由多个线程同时执行。

  • A 信号量 ,根据定义,将共享资源的并发用户数限制为最大数量

  • 信号量可以是互斥量,但互斥量永远不会是信号量。这只是意味着二进制信号量可以用作Mutex,但是Mutex永远不会展示信号量的功能。

  • 信号量和Mutex(至少是最新的内核)本质上都是非递归的。
  • 没有人拥有信号量,而Mutex是拥有的,所有者对它们负责。这是与调试角度的重要区别。
  • 在Mutex的情况下,拥有Mutex的线程负责释放它。但是,在信号量的情况下,不需要这种情况。任何其他线程都可以通过使用s m p s(function.e_ot)发信号来释放信号量

  • 另一个对开发人员很重要的区别是,信号量是系统范围的,并且保留在文件系统上的文件形式,除非另外清理。 Mutex是流程范围的,并在流程退出时自动清理。

  • 信号量的本质使得它们可以在同步相关和不相关的进程以及线程之间使用它们。 Mutex只能用于线程之间的同步,最多只能用于相关进程之间(最新内核的pthread实现带有一个允许在相关进程之间使用Mutex的功能)。
  • 根据内核文档,与信号量相比,Mutex更轻。这意味着与具有Mutex的程序相比,具有信号量使用的程序具有更高的内存占用。
  • 从使用角度来看,与信号量相比,Mutex具有更简单的语义。
35
Varun Chhangani

在理论层面,它们在语义上没有区别。您可以使用信号量实现互斥锁,反之亦然(参见 here 示例)。在实践中,实施是不同的,它们提供略有不同的服务。

实际差异(就其周围的系统服务而言)是互斥体的实现旨在成为更轻量级的同步机制。在Oracle中,互斥量称为 latches ,信号量称为 等待

在最低级别,他们使用某种原子 测试和设置 机制。这将读取内存位置的当前值,计算某种条件,并在单个指令中写出该位置的值 不能被中断 。这意味着您可以获取互斥锁并进行测试以查看是否有其他人在您之前拥有它。

典型的互斥实现有一个进程或线程执行测试和设置指令,并评估是否有其他设置互斥锁。这里的一个关键点是没有与 scheduler 的交互,所以我们不知道(并且不关心)谁设置了锁。然后我们放弃我们的时间片并在重新安排任务时再次尝试或执行 spin-lock 。自旋锁是一种算法,如:

Count down from 5000:
     i. Execute the test-and-set instruction
    ii. If the mutex is clear, we have acquired it in the previous instruction 
        so we can exit the loop
   iii. When we get to zero, give up our time slice.

当我们完成执行受保护的代码(称为 临界区 )时,我们只需将互斥量值设置为零或任何“清除”的方式。如果多个任务正在尝试获取互斥锁,则在释放互斥锁后恰好安排的下一个任务将获得对该资源的访问权限。通常,您将使用互斥锁来控制同步资源,其中仅在非常短的时间段内需要独占访问,通常是为了更新共享数据结构。

信号量是一种同步数据结构(通常使用互斥锁),它具有计数和一些系统调用包装,它们与调度程序交互的程度比互斥库更深。信号量递增和递减并用于 阻止 任务,直到其他东西准备就绪。请参阅 生产者/消费者问题 这是一个简单的例子。信号量初始化为某个值 - 二进制信号量只是信号量初始化为1的特殊情况。发布信号量可以唤醒等待进程。

基本信号量算法如下所示:

(somewhere in the program startup)
Initialise the semaphore to its start-up value.

Acquiring a semaphore
   i. (synchronised) Attempt to decrement the semaphore value
  ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice.

Posting a semaphore
   i. (synchronised) Increment the semaphore value
  ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable.  
 iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting.

在二进制信号量的情况下,两者之间的主要实际差异是围绕实际数据结构的系统服务的性质。

编辑:正如埃文正确指出的那样,自旋锁将减慢单处理器机器的速度。您只能在多处理器盒上使用自旋锁,因为在单个处理器上,当另一个任务正在运行时,持有互斥锁的进程将永远不会重置它。自旋锁只适用于多处理器架构。

21
ConcernedOfTunbridgeWells

虽然互斥和信号量被用作同步原语,但它们之间存在很大差异。在互斥锁的情况下,只有锁定或获取互斥锁的线程才能解锁它。在信号量的情况下,等待信号量的线程可以由不同的线程发信号通知。某些操作系统支持在进程之间使用互斥锁和信号量。通常用法是在共享内存中创建。

18
Praveen_Shukla

Mutex:假设我们有关键部分线程T1想要访问它,然后它遵循以下步骤。 T1:

  1. 使用关键部分
  2. 开锁

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

  1. wait(s)//最初s值在调用之后等于它的值减少了1,即0
  2. 使用关键部分
  3. signal(s)//现在s值增加,变为1

Mutex和Binary信号量之间的主要区别在于Mutext如果线程锁定临界区然后它必须解锁临界区而没有其他线程可以解锁它,但是在Binary信号量的情况下如果一个线程使用wait(s)函数锁定临界区然后值s变为“0”并且没有人可以访问它,直到“s”的值变为1但是假设某些其他线程调用信号然后“s”的值变为1并且它允许其他功能使用临界区。因此在Binary信号量线程中没有所有权。

11
Sumit Naik

你显然使用互斥锁来锁定一个线程中的数据,同时被另一个线程访问。假设您刚刚调用了lock()并且正在访问数据。这意味着您不希望任何其他线程(或相同线程代码的另一个实例)访问由同一个互斥锁锁定的相同数据。也就是说,如果在不同的线程实例上执行相同的线程代码,则命中锁,然后lock()应该阻止那里的控制流。这适用于使用不同线程代码的线程,该线程代码也访问相同的数据,并且也被同一个互斥锁锁定。在这种情况下,您仍然在访问数据的过程中,您可能需要另外15秒来达到互斥锁解锁(以便在互斥锁中被阻止的另一个线程将解锁并允许控制权访问数据)。您是否不惜一切代价允许另一个线程解锁相同的互斥锁,反过来又允许已经在互斥锁中等待(阻塞)的线程解除阻塞并访问数据?希望你能得到我在这里说的话?根据,同意普遍定义!,

  • 用“互斥”这种情况不可能发生。没有其他线程可以解锁线程中的锁
  • 使用“二进制信号量”可能会发生这种情况。任何其他线程都可以解锁线程中的锁

所以,如果你非常特别使用二进制信号量而不是互斥量,那么你应该非常小心地“确定”锁定和解锁。我的意思是,每次锁定的每个控制流都应该打一个解锁电话,也不应该有任何“第一次解锁”,而应该始终是“第一次锁定”。

10
paxi

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

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

10
Jamshad Ahmad

在Windows上,互斥锁和二进制信号量之间存在两个不同之处:

  1. 互斥锁只能由拥有所有权的线程释放,即先前调用Wait函数的线程(或者在创建它时获得所有权)。任何线程都可以释放信号量。

  2. 线程可以在互斥锁上重复调用等待函数而不会阻塞。但是,如果在二进制信号量上调用等待函数两次而不释放其间的信号量,则线程将阻塞。

10
Rich

神话:

几篇文章说“二进制信号量和互斥量相同”或“值为1的信号量是互斥量”,但基本的区别是Mutex只能由获取它的线程释放,而你可以从任何其他线程发出信号量信号

关键点:

•线程可以获取多个锁(Mutex)。

•只有当互斥锁具有递归互斥锁时,互斥锁才能锁定多次,此处锁定和解锁互斥锁应该相同

•如果已经锁定互斥锁的线程尝试再次锁定互斥锁,它将进入该互斥锁的等待列表,从而导致死锁。

•二进制信号量和互斥量相似但不相同。

•由于与之相关的保护协议,互斥锁的运行成本很高。

•互斥锁的主要目标是实现原子访问或锁定资源

9
Saurabh Sinha

A Mutex 控制对单个共享资源的访问。它提供操作 获取() 访问该资源和 release() 它完成后。

A 信号量 控制对共享资源池的访问。它向 Wait() 提供操作,直到池中的一个资源变为可用,和 Signal() 当它被返回池时。

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

因此,信号量是一种比Mutex更高级别的抽象。可以使用信号量实现互斥锁,但不能相反。

8
Charan

修改过的问题是 - “Linux”中的互斥锁和“二进制”信号量有什么区别?

Ans:以下是差异 - i)范围 - 互斥体的范围在创建它的进程地址空间内,并用于线程同步。信号量可以跨进程空间使用,因此可以用于进程间同步。

ii)Mutex比信号量轻,速度快。 Futex甚至更快。

iii)互斥锁可以被同一个线程多次成功获取,条件是它应该释放相同的次数。尝试获取的其他线程将阻止。而在信号量的情况下,如果相同的进程再次尝试获取它,则它会阻塞,因为它只能被获取一次。

6
Mickey

Mutex致力于阻止关键区域,但Semaphore依赖于计数。

6
Askkan

Binary Semaphore和Mutex之间的差异:OWNERSHIP: 信号量甚至可以从非当前所有者发出信号(发布)。这意味着您可以简单地从任何其他线程发布,但您不是所有者。

信号量是一个正在处理的公共财产,它可以简单地由非所有者线程发布。请用粗体字母标记这个区别,这意味着很多。

5
buddingspacer

http://www.geeksforgeeks.org/archives/9102 详细讨论。

Mutex是用于同步对资源的访问的锁定机制。 Semaphore是信令机制。

如果他/她想使用二进制信号量代替互斥锁,那么它应该由程序员完成。

5
user1852497

在Windows中,差异如下。 MUTEX: 进程成功执行 等待 必须执行 信号 反之亦然。 BINARY SEMAPHORES: 不同的进程可以在信号量上执行 等待 信号 操作。

4
ajay bidari

除了互斥锁具有所有者之外,这两个对象可以针对不同的用途进行优化。互斥锁的设计只能在短时间内保存;违反此规定可能会导致性能不佳和不公平的安排。例如,可以允许正在运行的线程获取互斥锁,即使另一个线程已经被阻塞。信号量可以提供更多的公平性,或者可以使用多个条件变量来强制公平。

4
jilles

经过上述帖子后,这个概念对我来说很清楚。但是有一些挥之不去的问题。所以,我写了这段小代码。

当我们试图给出一个信号量而不接受它时,它就会通过。但是,当你尝试不使用互斥锁时,它会失败。我在Windows平台上测试了这个。启用USE_MUTEX以使用MUTEX运行相同的代码。

#include <stdio.h>
#include <windows.h>
#define xUSE_MUTEX 1
#define MAX_SEM_COUNT 1

DWORD WINAPI Thread_no_1( LPVOID lpParam );
DWORD WINAPI Thread_no_2( LPVOID lpParam );

HANDLE Handle_Of_Thread_1 = 0;
HANDLE Handle_Of_Thread_2 = 0;
int Data_Of_Thread_1 = 1;
int Data_Of_Thread_2 = 2;
HANDLE ghMutex = NULL;
HANDLE ghSemaphore = NULL;


int main(void)
{

#ifdef USE_MUTEX
    ghMutex = CreateMutex( NULL, FALSE, NULL);
    if (ghMutex  == NULL) 
    {
        printf("CreateMutex error: %d\n", GetLastError());
        return 1;
    }
#else
    // Create a semaphore with initial and max counts of MAX_SEM_COUNT
    ghSemaphore = CreateSemaphore(NULL,MAX_SEM_COUNT,MAX_SEM_COUNT,NULL);
    if (ghSemaphore == NULL) 
    {
        printf("CreateSemaphore error: %d\n", GetLastError());
        return 1;
    }
#endif
    // Create thread 1.
    Handle_Of_Thread_1 = CreateThread( NULL, 0,Thread_no_1, &Data_Of_Thread_1, 0, NULL);  
    if ( Handle_Of_Thread_1 == NULL)
    {
        printf("Create first thread problem \n");
        return 1;
    }

    /* sleep for 5 seconds **/
    Sleep(5 * 1000);

    /*Create thread 2 */
    Handle_Of_Thread_2 = CreateThread( NULL, 0,Thread_no_2, &Data_Of_Thread_2, 0, NULL);  
    if ( Handle_Of_Thread_2 == NULL)
    {
        printf("Create second thread problem \n");
        return 1;
    }

    // Sleep for 20 seconds
    Sleep(20 * 1000);

    printf("Out of the program \n");
    return 0;
}


int my_critical_section_code(HANDLE thread_handle)
{

#ifdef USE_MUTEX
    if(thread_handle == Handle_Of_Thread_1)
    {
        /* get the lock */
        WaitForSingleObject(ghMutex, INFINITE);
        printf("Thread 1 holding the mutex \n");
    }
#else
    /* get the semaphore */
    if(thread_handle == Handle_Of_Thread_1)
    {
        WaitForSingleObject(ghSemaphore, INFINITE);
        printf("Thread 1 holding semaphore \n");
    }
#endif

    if(thread_handle == Handle_Of_Thread_1)
    {
        /* sleep for 10 seconds */
        Sleep(10 * 1000);
#ifdef USE_MUTEX
        printf("Thread 1 about to release mutex \n");
#else
        printf("Thread 1 about to release semaphore \n");
#endif
    }
    else
    {
        /* sleep for 3 secconds */
        Sleep(3 * 1000);
    }

#ifdef USE_MUTEX
    /* release the lock*/
    if(!ReleaseMutex(ghMutex))
    {
        printf("Release Mutex error in thread %d: error # %d\n", (thread_handle == Handle_Of_Thread_1 ? 1:2),GetLastError());
    }
#else
    if (!ReleaseSemaphore(ghSemaphore,1,NULL) )      
    {
        printf("ReleaseSemaphore error in thread %d: error # %d\n",(thread_handle == Handle_Of_Thread_1 ? 1:2), GetLastError());
    }
#endif

    return 0;
}

DWORD WINAPI Thread_no_1( LPVOID lpParam ) 
{ 
    my_critical_section_code(Handle_Of_Thread_1);
    return 0;
}


DWORD WINAPI Thread_no_2( LPVOID lpParam ) 
{
    my_critical_section_code(Handle_Of_Thread_2);
    return 0;
}
4
Raghav Navada

虽然二进制信号量可以用作互斥锁,但互斥锁是更具体的用例,因为只有锁定互斥锁的进程才能解锁它。此所有权约束可以提供以下保护:

  • 意外释放
  • 递归死锁
  • 任务死亡僵局

这些约束并不总是存在,因为它们会降低速度。在开发代码期间,您可以临时启用这些检查。

例如您可以在互斥锁中启用错误检查属性。如果您尝试锁定相同的两次,则检查互斥锁的错误将返回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");
3
Adi06411

Mutex用于保护敏感代码和数据,信号量用于同步。您也可以实际使用保护敏感代码,但是可能存在通过操作V由其他线程释放保护的风险。双信号量和互斥量之间的区别就是所有权。例如通过厕所,Mutex就像是可以进入厕所并锁上门,没有其他人可以进入,直到男人离开,双信号量就像一个人可以进入厕所和锁门,但其他人可以通过要求管理员打开门进入,这是荒谬的。

2
mannnnerd

与信号量不同,互斥量具有所有权。虽然在互斥体范围内的任何线程都可以获得解锁的互斥锁并锁定对相同关键代码段的访问,只有锁定互斥锁的线程 应该 解锁它

1
laksbv

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

在互斥锁的情况下,只有锁定它的线程才能解锁它。如果任何其他线程锁定它,它将等待。

在semaphone的情况下,情况并非如此。信号量与特定的线程ID无关。

1
Neeraj Sh

答案可能取决于目标操作系统。例如,我熟悉的至少一个RTOS实现将允许对单个OS互斥锁进行多个顺序“获取”操作,只要它们都来自同一个线程上下文。在允许另一个线程获取互斥锁之前,必须用相同数量的put替换多个gets。 这与二进制信号量不同,二进制信号量一次只允许一次获取,而不管线程上下文。

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

{
    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。

1
Casey Barker

正如这里的许多人所提到的,互斥锁用于保护关键代码段(AKA临界区)。您将获得互斥锁(锁定),输入临界区,并释放互斥锁(解锁) 所有这些都在同一个线程中

在使用信号量时,可以让线程等待信号量(比如线程A),直到另一个线程(比如线程B)完成任何任务,然后设置线程A的信号量以停止等待,并继续其任务。

1
Dom045

“二进制信号量”是一种编程语言,可以使用像"mutex"这样的“信号量”。显然有两个非常大的差异:

  1. 你打电话给他们的方式。

  2. “标识符”的最大长度。

0
ilias iliadis