{
  "id": "mutual-exclusion",
  "title": "互斥",
  "lang": "zh-Hans",
  "source_lang": "en",
  "summary": "互斥可防止并发活动同时进入受保护的临界区，从而协调对共享资源的访问。",
  "category": "computer-science",
  "subcategory": "software",
  "type": "concept",
  "aliases": [
    "互斥访问"
  ],
  "generated_at": "2026-11-03",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/zh/mutual-exclusion/",
  "translations": {
    "en": {
      "url": "https://aiwiki.page/en/mutual-exclusion/",
      "json": "https://aiwiki.page/en/mutual-exclusion.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "互斥是计算系统的一种性质，可防止两个或更多并发活动同时处于同一个受保护的临界区内。这些活动可以是进程、线程、处理器核心，也可以是分布式系统中的参与者。临界区是一段计算过程，其中会访问某种资源，或维护某个在操作重叠执行时可能遭到破坏的不变量。实现互斥的机制包括软件协议、硬件支持的锁、操作系统的互斥锁，以及分布式协调算法。\n\n互斥是并发计算的基础，因为程序中用单条语句表达的操作，往往由多个分别执行的步骤组成。如果缺乏协调，这些步骤就可能交错执行，导致更新丢失、数据结构不一致或资源状态无效。独占访问使一组操作在遵循同一协议的其他参与者看来如同不可分割的整体。\n\n这一主题涉及算法设计、处理器体系结构、编程语言语义、操作系统和分布式计算。其核心在于区分安全性与进展性：前者意味着不相容的活动绝不会重叠执行，后者意味着活动最终能够继续执行。一种机制可能满足其中一项，却不满足另一项；实际实现还必须处理内存可见性、调度、故障和性能等问题。"
    },
    {
      "heading": "临界区问题及其保证",
      "text": "经典的临界区问题考虑的是多个按顺序执行的参与者，它们反复执行与共享资源无关的工作、请求进入受保护区域、执行该区域中的代码，然后退出。进入协议决定参与者何时可以进入；退出协议则使资源重新可用。各参与者的执行速度不必相同，其指令可以由操作系统交错执行，也可以由不同的处理器同时执行。\n\n对于 \\(n\\) 个参与者，令 \\(C_i\\) 表示参与者 \\(i\\) 正处于其临界区内。互斥要求为\n\n\\[\\sum_{i=1}^{n}\\mathbf{1}[C_i]\\leq 1,\\]\n\n其中，当 \\(C_i\\) 为真时，\\(\\mathbf{1}[C_i]\\) 为 1，否则为 0。这是一项安全性属性：只要某次有限的执行过程中出现两个参与者同时处于临界区内，就能证明该属性遭到违反。这项要求通常分别适用于每个受保护的资源。两把互不相关的锁完全可以允许两个临界区同时执行。\n\n一个典型例子是初始值为 10 的共享计数器。两个线程各执行一次递增操作，每次递增都由加载、加法和存储三个步骤实现。两个线程可能都加载到 10，计算出 11，再将 11 存回，尽管预期结果应为 12。这就是竞态条件。对完整的“读—改—写”序列加锁，可以防止这种特定的交错执行，前提是所有相互冲突的访问都使用同一把锁。只对最后的存储步骤加锁，并不能保护旧值与新值之间的关系。\n\n进展要求进一步细化了规范。无死锁意味着，如果参与者持续请求进入，且相关执行假设成立，那么最终会有某个参与者进入。无饥饿意味着，每个请求进入的参与者最终都能进入。有界等待则限制了某个参与者提出访问请求后，其他参与者能够进入的次数。这些保证不能相互替代：一把锁可能不断允许某些线程进入，却无限期地跳过另一个线程。这些保证还依赖于一些假设，例如参与者最终会获得处理器调度，以及临界区最终会执行完毕。\n\n独占访问并不等于在每个抽象层次上都具有不可分割性。锁只能保护遵守其协议的代码；未参与协调的读取方仍可能看到中间状态。同样，分别对两个字段加锁，也不会自动维持涉及这两个字段的不变式。因此，正确的设计应先明确受保护的状态，以及哪些操作必须维持其不变式，再选择实现方式。需要保护的单位往往是整个数据结构或对象之间的关系，而不是单个内存位置。"
    },
    {
      "heading": "经典软件算法及其历史意义",
      "text": "随着计算机开始支持多道程序设计和共享内存并发，互斥成为一个基础性问题。1965 年，艾兹赫尔·W. 迪杰斯特拉发表了《并发程序控制中一个问题的解法》，将这一问题表述为顺序进程之间的协调问题。难点在于，如何在不依赖各进程相对执行速度的情况下，实现独占进入。早期的解决方案表明，即使没有专门的硬件锁指令，精心安排的读写操作也能协调各个参与者。\n\n一种简单的方法是使用一个共享变量，指示当前轮到谁。对于两个参与者，只有 turn 指定的参与者才能进入，并在退出时将机会交给另一方。在所假定的内存模型下，这种方法能够保证互斥，但它强制双方严格交替：即便另一方正在处理无关工作，完全无意进入临界区，当前一方也可能被阻塞。这个例子说明，仅有互斥性，还不足以构成一个实用解决方案的完整规约。\n\nDekker 算法由荷兰数学家 Theodorus Dekker 提出，并在迪杰斯特拉的著作中得到介绍。它将进入意愿标志与轮次变量结合起来。如果双方都希望进入，就由轮次变量打破僵局，其中一方暂时撤回请求。Gary L. Peterson 于 1981 年提出的双参与者算法，则给出了一种格外简洁的实现。参与者 \\(i\\) 执行以下步骤，其中 \\(j\\) 表示另一位参与者：\n\ninterested[i] = true\nturn = j\nwhile interested[j] and turn == j:\n    wait\ncritical section\ninterested[i] = false\n\n两个意愿标志用于区分正在竞争进入的参与者和未参与竞争的参与者。轮次变量用于处理同时发出的请求：如果两个标志都为真，最后一次轮次赋值所指定的参与者会等待，而另一方则可以进入。标准证明假定，对这些变量的访问具有原子性，且观察结果符合顺序一致性。在现代编程语言中，直接用普通共享变量实现这段伪代码，并不能保留这些假设。\n\n对于多个参与者，莱斯利·兰波特于 1974 年提出的面包店算法采用带编号的票号，类似于在商店取号排队。参与者选取一个大于其所观察到的所有票号的号码，然后等待所有排序在自己之前的竞争者。排序依据是由票号和参与者标识符组成的有序对；票号相同时，由标识符决定先后。“正在选号”标志可防止参与者将另一方尚未完成的选号过程误认为已经完成。值得注意的是，对于某些单写者寄存器上与写操作重叠的读操作，兰波特最初的算法允许采用格外宽松的假设。\n\n即使生产环境中的锁依赖专用指令，这些算法在教学和形式验证中仍然十分重要。它们将逻辑上的协调问题与操作系统提供的机制分离开来，清楚地揭示了哪些假设不可或缺。它们也说明，一些看似无害的简化——去掉打破平局的机制、改变两次赋值的顺序，或假定可见的标志必然反映最新状态——都可能破坏互斥性或进展性。"
    },
    {
      "heading": "原子指令与内存顺序",
      "text": "现代处理器提供原子操作，将对某个内存位置的读取和修改合并为一个不可分割的操作。常见的例子包括测试并设置、原子交换、获取并相加，以及比较并交换。测试并设置操作在将标志设为锁定状态的同时，返回其先前的值。如果旧值表示未锁定，调用者就获得了锁；否则，调用者必须等待或重试。比较并交换仅在某个位置的当前值与预期值相符时，才修改该位置的值。\n\n这些指令解决了多个执行者争相获取锁的直接问题，但仅保证锁字的原子性，还不足以保护普通数据。编译器可以变换代码，处理器也可以在遵守其体系结构规则的前提下，以不同于源代码顺序的次序执行内存操作。因此，锁操作还必须在不同临界区内的访问之间建立适当的顺序。这一要求由内存模型描述，内存模型规定了并发执行可能产生哪些可观察结果。\n\n一种常见的加锁模式是在成功获取锁时使用获取语义，在解锁时使用释放语义。通俗地说，释放操作通过同步协议，使此前对受保护数据的更新对其他执行者可见；获取操作则防止后续对受保护数据的访问被观察为发生在获取操作之前。更准确地说，当获取操作观察到相应的释放操作时，语言或硬件模型便会在此前和此后的访问之间建立顺序关系。在遵守整个程序的同步规则的前提下，这使锁的新持有者能够观察到前一持有者留下的状态。\n\nC11 和 C++11 标准引入了标准化的原子操作机制和形式化的内存模型。在这些语言中，来自不同线程的非原子访问如果相互冲突，且其中至少有一次是写入，那么除非这些访问之间建立了适当的顺序，否则就构成数据竞争；数据竞争会导致未定义行为。将锁标志声明为 volatile，既不能使其更新具有原子性，也不能建立线程间同步。正确的底层实现应当使用语言提供的原子操作、受支持的库设施，或有明确规范的平台原语。\n\n底层的中央处理器和内存系统在很大程度上决定了实现成本。对可缓存内存执行原子操作时，通常需要通过缓存一致性协议取得某条缓存行的独占所有权。这些操作并不一定会锁住整个内存总线，但某些指令或内存配置可能造成更大范围的干扰。包含争用锁的 CPU 缓存行可能在各个核心之间反复转移，使一个逻辑上极其简单的操作变得代价高昂。\n\n内存顺序也解释了为什么在现代机器上使用经典算法时需要格外谨慎。彼得森算法在教科书所列的假设下是正确的，但 C 或 C++ 中的普通读写操作并不能满足这些假设。使用具有顺序一致性的原子变量，可以重现标准的推理过程；采用更弱的内存顺序，则需要另行给出兼顾体系结构与语言规则的证明。单个标志的原子性，与不同标志之间访问的顺序，是两个不同的问题。"
    },
    {
      "heading": "自旋、阻塞与操作系统互斥锁",
      "text": "自旋锁通过反复检查锁的状态或尝试获取锁来等待。自旋避免了让线程休眠后再将其唤醒的直接开销，因此，当受保护的操作耗时很短，且持锁者正在另一个处理器上运行时，自旋可能是合适的选择。它的主要代价是等待者会持续消耗执行资源。如果持锁者已被调度器暂停运行，自旋就可能耗费整整一个调度时间片，等待当前根本无法推进的操作。\n\n相比之下，阻塞锁会让等待中的线程停止运行，直到可能有机会获取锁。这通常需要调度器的配合，并使用队列或等效结构记录等待者。阻塞会引入状态记录与维护的开销，还可能涉及系统调用、上下文切换以及缓存状态扰动。不过，它能让处理器执行其他无关任务，在等待可能持续较长时间时不可或缺。唤醒通常只是让线程具备运行资格，并不保证它立即执行或获得锁的所有权。\n\n互斥锁是对独占所有权的抽象，并不限定采用哪一种等待方式。许多实现将无竞争时的快速路径与有竞争时的慢速路径结合起来。快速路径以原子方式修改用户空间中的锁字。只有当竞争持续存在时，实现才会请求内核挂起调用线程。在 Linux 上，快速用户空间互斥机制支持这种安排：只有在某个用户空间字仍等于预期值时，线程才会进入等待，而另一个线程可以请求唤醒等待者。\n\nfutex 等待的条件性解决了一种关键的竞态。假设一个准备等待的线程先检查锁，随后持锁者释放了锁，最后该等待线程才尝试休眠。无条件休眠可能会错过这次释放，导致线程一直阻塞，且此后再也没有唤醒机会。相对于 futex 操作，以原子方式完成字值比较和等待登记，可以消除这一特定的唤醒丢失窗口。完整的互斥锁仍然需要正确的用户空间协议，以处理所有权、等待者记录和内存顺序。\n\n内核锁还面临额外的约束。禁用中断可以防止当前处理器上的某些重入情况，却无法排除另一个处理器上的执行。反过来，如果同一处理器上的中断处理程序能够抢占持锁者，并尝试获取同一把锁，那么仅使用自旋锁也可能不够。因此，内核接口会区分不同的执行上下文，并可能将自旋锁与本地中断控制结合使用。持有专供不可休眠上下文使用的锁时进入休眠，可能破坏调度器或内核必须维持的不变式。\n\n库提供的互斥锁，其行为因接口而异。可移植操作系统接口区分了不同的互斥锁类型和属性，涉及递归加锁、错误检查、进程间共享、健壮性和优先级协议。递归互斥锁允许持锁者反复获取同一把锁，并维护获取次数；它并不允许另一个线程同时进入。进程共享互斥锁还必须放置在参与进程都能访问的内存中。这些性质属于接口约定，并不是所有被称为“锁”的对象都普遍具备的特征。"
    },
    {
      "heading": "结构化同步与不变式保护",
      "text": "互斥与明确的抽象相结合时，最能发挥作用。例如，一个包含队列的对象可以用同一个互斥锁来保护头指针、尾指针、元素数量以及各节点的链接关系。这些字段共同构成一个不变式：指针与元素数量必须描述同一个队列。如果分别保护各个字段，就可能暴露出从未对应过有效队列状态的字段组合。因此，同步边界应当围绕插入、移除等逻辑操作来划定，而不应仅仅依据各个变量的布局。\n\n管程将受保护的状态与在互斥条件下执行的操作结合在一起。这一概念形成于20世纪70年代初，佩尔·布林奇·汉森和 C. A. R. 霍尔的相关工作尤为重要。管程式编程明确体现了数据与同步之间的关联。Java 的 synchronized 方法和代码块等语言结构提供了类似的机制，不过，具体语义取决于语言及其运行时环境。\n\n仅靠独占访问，无法高效地等待应用层条件成立。持有队列互斥锁的消费者可能发现队列为空；如果它一直持锁并反复检查，就会阻止生产者插入元素。条件变量通过允许消费者将释放互斥锁与进入等待作为一个协调操作来执行，解决了这一问题。等待操作会在返回受保护代码之前重新获取互斥锁。生产者则在持有互斥锁时改变队列状态，并发出信号，表明相关条件现在可能已经成立。\n\n条件等待通常应放在检验受保护谓词的循环中。被唤醒并不一定意味着等待者开始运行时谓词为真：另一个消费者可能已经先一步取走了元素，而且有些接口允许虚假唤醒。能够持续保留信息的是共享状态，而不是通知本身。这使条件变量有别于那些会保留可用许可数量的机制。\n\n信号量维护的正是这样的计数。获取操作在有可用许可时消耗一个许可，否则就等待；释放操作则增加一个许可。初始化为一的信号量，如果按照适当的协议使用，也能确保互斥进入，但它不同于传统的基于所有权的互斥锁。有些信号量接口允许获取者之外的参与者释放许可。因此，信号量适合用于通知和资源池，而互斥锁的所有权机制则支持那些需要识别持有者的检查与调度策略。\n\n程序结构也会影响锁能否可靠地释放。具备异常安全性的作用域守卫，例如 C++ 中采用“资源获取即初始化”（RAII）方式的封装，会将解锁操作与离开词法作用域绑定起来。其他语言中的锁语句或上下文管理器也采用了类似结构。它们能减少因提前返回或异常而意外未释放锁的情况，但无法解决所有生命周期或重入问题。如果受保护的代码调用了外部回调，该回调可能尝试获取同一把锁，或以不兼容的顺序获取另一把锁；要维护不变式，就必须将这类间接控制流纳入考虑。"
    },
    {
      "heading": "死锁、饥饿与优先级反转",
      "text": "系统即使能严格保证互斥，也仍可能无法取得有效进展。当一组参与者因组内的依赖关系而永久阻塞时，就会发生死锁。一个常见的锁示例是：线程 A 持有锁 \\(L_1\\)，同时等待 \\(L_2\\)；线程 B 持有 \\(L_2\\)，同时等待 \\(L_1\\)。两者都无法执行到释放锁的操作。经典的科夫曼条件指出，资源死锁涉及四个条件：互斥、持有资源并等待其他资源、资源不可被强制剥夺，以及循环等待。\n\n一种标准的预防方法是为所有锁规定一个全局顺序，并要求按此顺序获取锁。如果所有依赖都指向排序更高的锁，就不可能形成循环依赖链。但如果所需的锁取决于动态创建的对象，或相互独立的软件组件采用不同的约定，这种方法就很难实施。尝试加锁操作可以避免在持有另一个锁时陷入阻塞，但重试协议必须正确释放资源，并避免反复发生冲突。\n\n反复执行操作却无法取得有效进展的情况称为活锁。例如，两个线程可能同时检测到锁获取冲突，于是各自释放先前持有的锁，暂停相同的时间后，再同步重试。随机退避或非对称退避可以减少这种情况，但概率上的改善并不自动意味着能以确定性的方式保证进展。饥饿则有所不同：系统仍在取得进展，但某个参与者却无限期地无法获得访问机会。一个频繁运行的线程可能在等待线程获得调度之前，反复重新获取一个不保证公平性的互斥锁。\n\n当高优先级任务等待低优先级任务持有的锁时，就会出现优先级反转。如果中优先级任务不断抢占持锁任务，即使它们并不使用受保护的资源，也会延误高优先级任务。优先级继承会临时提高持锁任务的有效优先级，使其与因等待该锁而阻塞的高优先级任务相匹配。优先级上限协议则根据可能访问某项资源的任务，施加限制或调整优先级。这些机制在实时操作系统中尤为重要，因为阻塞时间会影响截止期限分析。\n\n1997 年的火星探路者任务提供了一个广为讨论的优先级反转案例，涉及共享信息总线上的一个互斥锁。低优先级任务可能持有高优先级任务所需的互斥锁，而中优先级任务的运行又延迟了锁的释放，进而导致看门狗触发复位。启用该互斥锁的优先级继承功能后，观测到的调度问题得到了解决。这个例子表明，互斥机制即使在逻辑上正确，也可能因与调度机制相互作用而造成运行故障。\n\n持锁期间发生故障还会带来另一类进展问题。崩溃的进程无法执行解锁操作。健壮互斥锁机制可以向后续获取锁的参与者报告原持有者已终止，但这并不能证明受保护的数据仍然一致。新的持有者可能需要修复尚未完成的更新，然后才能将状态标记为可用。同样，超时只能说明等待持续过久；它本身并不足以成为从一个可能仍在执行的参与者手中夺取锁所有权的理由。"
    },
    {
      "heading": "争用、公平性与多核可扩展性",
      "text": "锁的性能在很大程度上取决于争用情况。没有争用时，互斥锁可能只需要少量指令和一次成功的原子操作。争用激烈时，其开销则包括等待、缓存一致性流量、调度器活动，以及受保护操作的串行执行。因此，在单线程基准测试中表现良好的锁，在多个核心争抢时可能表现得截然不同。\n\n简单的测试并设置自旋锁会反复对同一个共享位置执行类似写入的原子操作。在锁仍被持有时，这可能产生不必要的缓存一致性流量。测试—测试并设置设计则先通过普通的原子加载读取锁状态，只有在锁看似空闲时，才尝试开销更高的获取操作。退避机制在重试之间引入延迟，以减少同时发起的尝试。这些技术改变的是流量模式，并不能消除临界区的串行执行。\n\n票号锁用一个计数器分配获取锁的票号，用另一个计数器指示当前轮到的票号。它以原子方式分配票号，从而提供明确的先到先得顺序。然而，等待者通常会轮询同一个表示当前票号的计数器，因此每次锁的交接都可能影响多个缓存。约翰·梅勒-克拉米（John Mellor-Crummey）和迈克尔·斯科特（Michael Scott）于 1991 年提出的 MCS 队列锁则将等待者连接成队列，让它们主要在各自关联的独立内存位置上自旋。这种设计减少了对单一集中轮询位置的争用，力求使每次获取锁所需的远程内存访问次数保持为常数。\n\n公平性既有好处，也有代价。对于显式维护等待队列的锁，如果指定的下一任持有者未获调度，即使另一个线程已经就绪，也可能出现护航效应。不公平的锁允许正在运行的线程立即获取锁，可能提高吞吐量，但也可能增大等待时间的波动。在非统一内存访问系统中，在相距较远的处理器插槽之间移交锁的所有权，也可能比在本地重复使用锁的开销更高。偏重局部性的设计必须在这一收益与公平性之间取得平衡。\n\n受保护的计算本身也会构成限制。如果执行过程中有固定比例 \\(s\\) 的部分本质上只能串行执行，那么在 \\(p\\) 个处理器上，理想化的加速比受以下关系约束：\n\n\\[S(p)\\leq \\frac{1}{s+(1-s)/p}.\\]\n\n这一阿姆达尔定律式的界限未计入锁的开销，因此实际的扩展效果可能更差。缩短临界区、将共享表拆分为分别加锁的独立分片，或让各线程分别累积结果，都可以降低串行部分的比例。更细粒度的加锁会引入额外的锁操作、顺序约束和出错机会，因此锁更多并不意味着性能一定更好。\n\n性能测量必须区分平均获取开销、吞吐量、尾延迟和公平性。如果一个无关但频繁修改的变量与锁或等待者标志位处于同一缓存行，伪共享就可能使结果失真。当可运行线程数超过处理器的承载能力时，如果锁的持有者没有运行，短暂的自旋等待也可能变成长时间延迟。因此，锁的基准测试结果只有结合工作负载特征、线程的核心分配、调度条件，以及受保护操作的持续时间及其波动来看，才有意义。"
    },
    {
      "heading": "分布式系统中的互斥",
      "text": "在分布式计算中，参与者通常无法通过一条作用于共享内存的原子指令来协调行动。它们通过网络交换消息，而网络延迟各不相同，各参与者也可能独立发生故障。因此，分布式互斥需要对通信、成员关系、故障以及受保护的资源作出明确假设。某个协议在所有参与者都能正常响应时可能是正确的，但在其中一个参与者崩溃后，就可能无法继续推进。\n\n最简单的设计是采用集中式协调器。参与者向同一个管理节点请求锁，该节点最多只将锁授予一个持有者，并将有冲突的请求排队等待。这样，协调问题就简化为维护一份唯一且权威的锁归属决定。然而，协调器故障可能导致锁无法获取，而替换过程若管理不当，则可能产生两个管理节点。采用复制机制的协调服务通常使用共识协议，例如 Raft共识算法，以便在部分服务器发生故障时，仍能维护一份按统一顺序更新的状态。\n\n基于许可的算法不指定单一协调器。Lamport 于 1978 年提出的互斥算法使用逻辑时间戳和参与者标识符对请求排序。在其标准形式中，\\(N\\) 个参与者之间每次获取锁需要交换 \\(3(N-1)\\) 条请求、确认和释放消息。1981 年发表的 Ricart–Agrawala 算法通过延迟回复，而不是另行广播释放消息，将标准消息数量降至 \\(2(N-1)\\)。这些数量描述的是基本算法在其通信和参与者假设下的消息开销，并不包含通用的故障恢复机制。\n\n基于令牌的算法以持有唯一令牌来表示进入临界区的权利。在逻辑环中，参与者会在适当时机将令牌传给后继参与者。令牌的唯一性保证了互斥，但故障恢复需要格外谨慎：令牌丢失会导致无法进入临界区，而重新生成令牌时处理不当又可能产生重复令牌。网络分区使这种区分尤为困难，因为收不到响应并不能说明另一个参与者究竟是发生了故障，还是仅仅无法通过网络访问。\n\n租约授予的权限具有时限，而非无限期有效。当持有者失去响应时，租约可以支持恢复，但其正确性取决于有关时间和强制执行的假设。客户端可能暂停很长时间，在租约到期后恢复运行，并继续发出写入操作。仅在开始工作前检查本地时钟，并不能阻止延迟的操作在新持有者接管后才到达。\n\n一种常见的补充机制是隔离令牌（fencing token），即每次授权时附带的、单调递增的代次编号。受保护的资源记录最近接受的代次，并拒绝携带更早代次的操作。这样，强制执行就被移到了冲突实际产生影响的位置。授权方必须以一致的方式发放令牌，而资源必须在执行操作的过程中验证令牌。如果没有存储系统或外部设备的配合，分布式锁服务未必能阻止已失去有效授权的旧持有者继续产生实际影响。"
    },
    {
      "heading": "验证与排他锁的替代方案",
      "text": "对锁进行推理，首先要明确受保护的不变式和同步协议。安全性证明表明，任何可达的执行过程都不会出现相互冲突的持有者。活性证明还必须说明有关调度和环境的假设：各参与者能够获得执行时间，必要的通信最终能够成功，持有者最终会退出临界区。如果没有这些假设，即使算法本身正确，也可能无法保证参与者最终能获取锁。\n\n模型检测通过探索状态及其转换来发现不允许出现的执行过程。仅包含两三个参与者的小型模型，往往就能暴露进入协议、唤醒处理或所有权转移中的错误。困难在于状态空间的膨胀：程序计数器、局部变量、队列内容和内存顺序的不同选择，会使可能的状态数量成倍增长。抽象和对称性约简可以将探索的复杂度控制在可处理的范围内，而演绎方法则利用不变式和数学证明来覆盖规模更大或无界的配置。\n\n动态竞态检测器提供了另一类证据。它们观察一次执行，识别缺少必要同步关系的冲突访问。锁顺序检查可以发现锁获取模式中潜在的环路。这两种技术中的任何一种都无法单独证明正确性：程序即使没有数据竞争，仍可能更新错误的对象、违反涉及多个对象的不变式，或者仅在未被观察到的执行中发生死锁。对于弱内存行为，还需要使用能够对相关语言和处理器语义建模的工具或证明方法。\n\n一些应用通过改变数据组织方式来避免使用排他锁。不可变对象可以直接共享，无须协调并发修改，因为根本不存在修改。所有权转移和消息传递则确保任一时刻仅有一个参与者控制可变状态。单个事件循环可以让处理程序串行执行，但异步挂起仍可能使逻辑上相关的操作在不同回调之间交错进行。避免机器层面的同时执行，并不意味着应用中的多步骤操作就自动成为不可分割的整体。\n\n无锁算法利用原子操作，使系统整体的推进不依赖于某个特定参与者持续运行。无等待算法提供了更强的保证：在所声明的模型下，每个操作都能在有限且有界的自身执行步数内完成。这些保证并不意味着没有重试、延迟低或实现简单。动态分配的数据结构还需要安全的内存回收机制：即使指针更新本身完全正确，一个线程移除的节点仍可能被另一个线程引用。\n\n其他机制放宽了只能有一个独占持有者的要求。读写锁允许多个读者并发访问，同时排除与之冲突的写者。读—复制—更新机制允许读者遍历适用的数据结构，而内存回收则等待已有读者完成访问后才进行。乐观方案先试探性地执行工作，再验证是否发生了冲突性修改。数据库事务可以结合锁、版本管理或验证机制，在更大范围内提供保证。每种方法都会改变需要证明的内容：正确性取决于观察者可能看到什么、如何检测冲突，以及被中断或失败的操作是否会留下外部可见的影响。"
    }
  ],
  "links": [
    "critical-section",
    "concurrent-computing",
    "operating-system",
    "race-condition",
    "data-structure",
    "formal-verification",
    "atomic-operation",
    "compiler",
    "memory-model",
    "central-processing-unit",
    "cpu-cache",
    "spinlock",
    "thread-computing",
    "system-call",
    "mutex",
    "linux",
    "posix",
    "condition-variable",
    "deadlock",
    "real-time-operating-system",
    "non-uniform-memory-access",
    "distributed-computing",
    "raft-consensus-algorithm",
    "model-checking",
    "event-loop",
    "database-transaction"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}