concurrency - 锁、互斥量和信号量有什么区别？

Question

我听说过这些与并发编程有关的词，但是锁、互斥量和信号量有什么区别？

Answer 1

锁只允许一个线程进入被锁定的部分，并且该锁不与任何其他进程共享。

互斥锁与锁相同，但它可以是系统范围的（由多个进程共享）。

信号量与互斥量相同，但允许 x个线程进入，例如，这可用于限制同时运行的 cpu、io 或 ram 密集型任务的数量。

有关互斥量和信号量之间差异的更详细的帖子，请阅读此处。

您还拥有读/写锁，在任何给定时间允许无限数量的读者或 1 个作者。

Answer 2

对这些词有很多误解。

这是来自上一篇文章（https://stackoverflow.com/a/24582076/3163691），非常适合这里：

1) 关键部分= 用户对象，用于允许在一个进程中仅执行来自许多其他线程的一个活动线程。其他未选择的线程（@获取此对象）进入睡眠状态。

[没有进程间能力，非常原始的对象]。

2) Mutex Semaphore (aka Mutex) = 内核对象，用于允许在不同进程中仅执行来自许多其他线程的一个活动线程。其他未选择的线程（@获取此对象）进入睡眠状态。该对象支持线程所有权、线程终止通知、递归（来自同一线程的多个“获取”调用）和“避免优先级反转”。

[进程间能力，使用非常安全，一种'高级'同步对象]。

3) Counting Semaphore (aka Semaphore) = 用于允许执行来自许多其他线程的一组活动线程的内核对象。其他未选择的线程（@获取此对象）进入睡眠状态。

[但是，进程间功能使用起来不是很安全，因为它缺少以下“互斥”属性：线程终止通知、递归？、“避免优先级反转”？等]。

4）现在，谈论“自旋锁”，首先是一些定义：

关键区域 = 由 2 个或更多进程共享的内存区域。

Lock= 一个变量，其值允许或拒绝进入“关键区域”。（它可以实现为一个简单的“布尔标志”）。

忙等待=不断测试变量，直到出现某个值。

最后：

自旋锁（又名自旋锁） =使用忙等待的锁。（锁的获取是通过xchg或类似的原子操作进行的）。

[无线程休眠，主要仅在内核级别使用。用户级代码效率低下]。

作为最后的评论，我不确定，但我可以向你打赌，上面的前 3 个同步对象（#1、#2 和 #3）利用这个简单的野兽（#4）作为其实现的一部分。

祝你有美好的一天！。

参考：

-Qing Li 和 Caroline Yao 合着的嵌入式系统的实时概念（CMP 书籍）。

-Andrew Tanenbaum（培生国际教育）的现代操作系统（第 3 次）。

- Jeffrey Richter（Microsoft 编程系列）的 Microsoft Windows 编程应用程序（第 4 期）。

另外，您可以看看： https ://stackoverflow.com/a/24586803/3163691

Answer 3

大多数问题都可以使用（i）仅锁，（ii）仅信号量，...或（iii）两者的组合来解决！正如您可能已经发现的那样，它们非常相似：都防止竞争条件，都具有acquire()/release()操作，都导致零个或多个线程被阻塞/怀疑......实际上，关键的区别仅在于它们如何锁定和解锁。

• 锁（或互斥锁）有两种状态（0 或 1）。它可以解锁或锁定。它们通常用于确保一次只有一个线程进入关键部分。
• 一个信号量有很多状态（0, 1, 2, ...）。它可以被锁定（状态 0）或解锁（状态 1、2、3，...）。一个或多个信号量通常一起使用，以确保当某些资源的单元数已/未达到特定值时（通过向下计数到该值或向上计数到该值），只有一个线程准确地进入临界区）。

acquire()对于这两种锁/信号量，在原语处于状态 0 时尝试调用会导致调用线程被挂起。对于锁 - 尝试获取处于状态 1 的锁是成功的。对于信号量 - 尝试在状态 {1, 2, 3, ...} 中获取锁是成功的。

对于状态为 0 的锁，如果之前调用过的同一个acquire()线程，现在调用 release，则释放成功。如果一个不同的线程尝试了这个——它取决于实现/库会发生什么（通常忽略尝试或抛出错误）。对于状态 0 的信号量，任何线程都可以调用 release 并且它会成功（无论之前使用哪个线程获取将信号量置于状态 0）。

从前面的讨论中，我们可以看到锁有一个所有者的概念（唯一可以调用释放的线程就是所有者），而信号量没有所有者（任何线程都可以在一个信号量上调用释放）。

---

造成很多混乱的原因是，实际上它们是这个高级定义的许多变体。

要考虑的重要变化：

• acquire()/应该release()叫什么？-- [变化很大]
• 您的锁/信号量是否使用“队列”或“集合”来记住等待的线程？
• 您的锁/信号量可以与其他进程的线程共享吗？
• 你的锁是“可重入的”吗？-- [通常是的]。
• 您的锁是“阻塞/非阻塞”吗？-- [通常非阻塞被用作阻塞锁（又名自旋锁）导致忙等待]。
• 您如何确保操作是“原子的”？

这些取决于您的书/讲师/语言/图书馆/环境。
这是一个快速浏览，注意一些语言如何回答这些细节。

---

C、C++（pthreads）

• 互斥锁是通过 实现的pthread_mutex_t。默认情况下，它们不能与任何其他进程（PTHREAD_PROCESS_PRIVATE）共享，但是互斥锁有一个名为pshared的属性。设置后，互斥锁在进程之间共享（PTHREAD_PROCESS_SHARED）。
• 锁与互斥锁是一样的。
• 信号量是通过 实现的sem_t。与互斥锁类似，信号量可以在多个进程的线程之间共享，也可以对单个进程的线程保持私有。这取决于提供给 的pshared参数sem_init。

蟒蛇（线程.py）

• 锁( ) 与C threading.RLock/C++pthread_mutex_t基本相同。两者都是可重入的。这意味着它们只能由锁定它的同一线程解锁。在这种情况下，sem_t信号量、threading.Semaphore信号量和theading.Lock锁是不可重入的——因为任何线程都可以执行解锁锁定/关闭信号量。
• 互斥锁与锁相同（该术语在 python 中不常用）。
• 信号量( threading.Semaphore)与sem_t. 尽管使用sem_t，但线程 ID 队列用于记住在锁定时尝试锁定线程时线程被阻塞的顺序。当一个线程解锁一个信号量时，队列中的第一个线程（如果有的话）被选为新的所有者。线程标识符从队列中取出，信号量再次锁定。但是，使用threading.Semaphore集合而不是队列，因此不会存储线程被阻塞的顺序——集合中的任何线程都可以被选择为下一个所有者。

Java ( java.util.concurrent )

• 锁( ) 与 C/C++和 Python 的大部分java.util.concurrent.ReentrantLock相同，因为它也实现了可重入锁。由于 JVM 充当中介，Java 中的进程之间共享锁更加困难。如果一个线程试图解锁一个它不拥有的锁，就会抛出一个。pthread_mutex_tthreading.RLockIllegalMonitorStateException
• 互斥锁与锁相同（该术语在 Java 中不常用）。
• 信号量( )与和java.util.concurrent.Semaphore基本相同。Java 信号量的构造函数接受一个公平布尔参数，该参数控制是使用集合 (false) 还是队列 (true) 来存储等待线程。 sem_tthreading.Semaphore

---

理论上，信号量经常被讨论，但在实践中，信号量的使用并不多。一个信号量只保存一个整数的状态，所以它通常相当不灵活，一次需要很多——导致难以理解代码。此外，任何线程都可以释放信号量这一事实有时是不受欢迎的。而是使用更多面向对象/更高级别的同步原语/抽象，例如“条件变量”和“监视器”。

Answer 4

看看John Kopplin 的多线程教程。

在线程间同步一节中，他解释了事件、锁、互斥、信号量、等待定时器的区别

互斥锁一次只能由一个线程拥有，使线程能够协调对共享资源的互斥访问

临界区对象提供类似于互斥对象提供的同步，除了临界区对象只能由单个进程的线程使用

互斥体和临界区之间的另一个区别是，如果临界区对象当前由另一个线程 拥有，EnterCriticalSection()则无限期地等待所有权 WaitForSingleObject()，而与互斥体一起使用的 允许您指定超时

信号量保持在零和某个最大值之间的计数，从而限制同时访问共享资源的线程数。

Answer 5

我将尝试用示例来介绍它：

锁定：您将使用的一个示例lock是在其中添加项目（必须具有唯一键）的共享字典。
锁将确保一个线程不会进入检查字典中项目的代码机制，而另一个线程（即在关键部分中）已经通过了此检查并正在添加项目。如果另一个线程试图输入一个锁定的代码，它将等待（被阻塞）直到对象被释放。

private static readonly Object obj = new Object();

lock (obj) //after object is locked no thread can come in and insert item into dictionary on a different thread right before other thread passed the check...
{
    if (!sharedDict.ContainsKey(key))
    {
        sharedDict.Add(item);
    }
}

信号量： 假设您有一个连接池，那么单个线程可能会通过等待信号量获得连接来保留池中的一个元素。然后它使用连接，当工作完成时通过释放信号量来释放连接。

我喜欢的代码示例是@Patric 给出的保镖之一- 它是这样的：

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace TheNightclub
{
    public class Program
    {
        public static Semaphore Bouncer { get; set; }

        public static void Main(string[] args)
        {
            // Create the semaphore with 3 slots, where 3 are available.
            Bouncer = new Semaphore(3, 3);

            // Open the nightclub.
            OpenNightclub();
        }

        public static void OpenNightclub()
        {
            for (int i = 1; i <= 50; i++)
            {
                // Let each guest enter on an own thread.
                Thread thread = new Thread(new ParameterizedThreadStart(Guest));
                thread.Start(i);
            }
        }

        public static void Guest(object args)
        {
            // Wait to enter the nightclub (a semaphore to be released).
            Console.WriteLine("Guest {0} is waiting to entering nightclub.", args);
            Bouncer.WaitOne();          

            // Do some dancing.
            Console.WriteLine("Guest {0} is doing some dancing.", args);
            Thread.Sleep(500);

            // Let one guest out (release one semaphore).
            Console.WriteLine("Guest {0} is leaving the nightclub.", args);
            Bouncer.Release(1);
        }
    }
}

互斥锁它几乎Semaphore(1,1)在全球范围内经常使用（应用范围广泛，否则可以说lock更合适）。从全局可访问列表中删除节点时会使用全局Mutex（在删除节点时您希望另一个线程做某事的最后一件事）。当您获取时，Mutex如果不同的线程尝试获取相同的Mutex内容，它将进入睡眠状态，直到获取它的相同线程Mutex释放它。

创建全局互斥锁的好例子是@deepee

class SingleGlobalInstance : IDisposable
{
    public bool hasHandle = false;
    Mutex mutex;

    private void InitMutex()
    {
        string appGuid = ((GuidAttribute)Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(GuidAttribute), false).GetValue(0)).Value.ToString();
        string mutexId = string.Format("Global\\{{{0}}}", appGuid);
        mutex = new Mutex(false, mutexId);

        var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null), MutexRights.FullControl, AccessControlType.Allow);
        var securitySettings = new MutexSecurity();
        securitySettings.AddAccessRule(allowEveryoneRule);
        mutex.SetAccessControl(securitySettings);
    }

    public SingleGlobalInstance(int timeOut)
    {
        InitMutex();
        try
        {
            if(timeOut < 0)
                hasHandle = mutex.WaitOne(Timeout.Infinite, false);
            else
                hasHandle = mutex.WaitOne(timeOut, false);

            if (hasHandle == false)
                throw new TimeoutException("Timeout waiting for exclusive access on SingleInstance");
        }
        catch (AbandonedMutexException)
        {
            hasHandle = true;
        }
    }


    public void Dispose()
    {
        if (mutex != null)
        {
            if (hasHandle)
                mutex.ReleaseMutex();
            mutex.Dispose();
        }
    }
}

然后像这样使用：

using (new SingleGlobalInstance(1000)) //1000ms timeout on global lock
{
    //Only 1 of these runs at a time
    GlobalNodeList.Remove(node)
}

希望这可以节省您一些时间。

Answer 6

维基百科对信号量和互斥量之间的区别有一个很好的部分：

互斥体本质上与二进制信号量相同，有时使用相同的基本实现。它们之间的区别是：

互斥体有一个所有者的概念，它是锁定互斥体的进程。只有锁定互斥锁的进程才能解锁它。相反，信号量没有所有者的概念。任何进程都可以解锁信号量。

与信号量不同，互斥锁提供优先级反转安全。由于互斥锁知道它的当前所有者，因此每当更高优先级的任务开始等待互斥锁时，就可以提升所有者的优先级。

互斥锁还提供删除安全性，其中持有互斥锁的进程不会被意外删除。信号量不提供此功能。

Answer 7

我的理解是，互斥锁只能在单个进程中使用，但可以跨多个线程使用，而信号量可以跨多个进程使用，并且可以跨对应的线程集使用。

此外，互斥锁是二进制的（它要么被锁定，要么被解锁），而信号量有一个计数的概念，或者一个包含多个锁定和解锁请求的队列。

有人可以验证我的解释吗？我是在 Linux 的上下文中说的，特别是 Red Hat Enterprise Linux (RHEL) 版本 6，它使用内核 2.6.32。

Answer 8

在 Linux 变体上使用 C 编程作为示例的基本案例。

锁：

• 通常是一个非常简单的构造二进制操作，无论是锁定的还是解锁的

• 没有线程所有权、优先级、排序等概念。

• 通常是一个自旋锁，其中线程不断检查锁的可用性。

• 通常依赖于原子操作，例如Test-and-set、compare-and-swap、fetch-and-add 等。

• 通常需要硬件支持原子操作。

文件锁：

• 通常用于协调通过多个进程对文件的访问。

• 多个进程可以持有读锁，但是当任何单个进程持有写锁时，不允许其他进程获得读锁或写锁。

• 示例：flock、fcntl 等。

互斥体：

• Mutex 函数调用通常在内核空间中工作并导致系统调用。

• 它使用所有权的概念。只有当前持有互斥锁的线程才能解锁它。

• Mutex 不是递归的（例外：PTHREAD_MUTEX_RECURSIVE）。

• 通常与条件变量关联使用并作为参数传递给例如pthread_cond_signal、pthread_cond_wait 等。

• 一些UNIX 系统允许多个进程使用互斥锁，尽管这可能并非在所有系统上都强制执行。

信号：

• 这是一个内核维护的整数，其值不允许低于零。

• 可用于同步进程。

• 信号量的值可以设置为大于 1 的值，在这种情况下，该值通常表示可用资源的数量。

• 值限制为 1 和 0 的信号量称为二进制信号量。

Answer 9

锁、互斥量、信号量

这是一个普遍的愿景。细节取决于真实的语言实现

lock- 线程同步工具。当线程获得锁时，它成为能够执行代码块的单个线程。所有其他线程都被阻塞。只有拥有锁的线程才能解锁

mutex- 互斥锁。它是一种锁。在某些语言上它是进程间机制，在某些语言上它是lock. 例如 Javalock在synchronised和java.util.concurrent.locks.Lock

semaphore- 允许多个线程访问共享资源。你可以发现，mutex也可以通过semaphore. 它是一个独立的对象，管理对共享资源的访问。你可以发现任何线程都可以signal解除阻塞。它也用于发信号

【iOS锁、互斥量、信号量】

Answer 10

Supporting ownership,maximum number of processes share lock和maximum number of allowed processes/threads in critical section是确定通用名称为 的并发对象的名称/类型的三个主要因素lock。由于这些因子的值是二元的（有两种状态），我们可以将它们汇总在一个 3*8 的类真值表中。

• X（支持所有权？）：否（0）/是（1）
• Y（#共享进程）：> 1 (∞) / 1
• Z（CA 中的#processes/threads）：> 1 (∞) / 1

---

  X   Y   Z          Name
 --- --- --- ------------------------
  0   ∞   ∞   Semaphore              
  0   ∞   1   Binary Semaphore       
  0   1   ∞   SemaphoreSlim          
  0   1   1   Binary SemaphoreSlim(?)
  1   ∞   ∞   Recursive-Mutex(?)     
  1   ∞   1   Mutex                  
  1   1   ∞   N/A(?)                 
  1   1   1   Lock/Monitor           

随意编辑或扩展此表，我已将其发布为可编辑的 ascii 表:)