本文深入探讨python多线程编程中常见的竞态条件问题，解释了为何在特定操作系统环境下，非同步代码可能看似正常运行。通过分析线程调度原理，并引入`threading.barrier`同步原语，演示如何显式地暴露并解决共享资源访问冲突，强调了在多线程环境中确保数据一致性的重要性。

在多线程编程中，当多个线程并发访问和修改同一个共享资源时，如果没有适当的同步机制，就可能发生竞态条件（Race Condition）。竞态条件会导致程序行为的不确定性，最终产生错误的结果。一个经典的例子是对共享变量进行简单的增减操作。

理解竞态条件及其非原子性操作

考虑以下python代码片段，其中两个线程并发地对一个全局变量x进行一百万次的增减操作：

import threading import os  x = 0;  class Thread1(threading.Thread):            def run(self):          global x         for i in range(1,1000000):             x = x + 1  class Thread2(threading.Thread):     def run(self):           global x         for i in range(1,1000000):             x = x - 1 t1 = Thread1() t2 = Thread2() t1.start() t2.start() t1.join() t2.join()  print("Sum is "+str(x));

理论上，如果两个线程各自执行一百万次加1和减1操作，最终x的值应该为0。然而，实际运行结果往往并非如此，通常会得到一个非零值。这是因为x = x + 1和x = x – 1这类操作并非原子性的。在底层，它们通常涉及以下三个步骤：

1. 读取x的当前值。
2. 对读取的值进行加1（或减1）运算。
3. 将新值写回x。

当多个线程并发执行这些步骤时，它们的执行顺序可能会交错，导致一个线程的中间结果被另一个线程覆盖，从而丢失更新。例如：

立即学习“Python免费学习笔记（深入）”；

1. 线程A读取x（假设x为0）。
2. 线程B读取x（此时x仍为0）。
3. 线程A将x加1（x变为1）。
4. 线程B将x减1（x变为-1）。 在这种情况下，一次加法和一次减法操作最终导致x变为-1，而不是0，一次更新丢失了。

操作系统调度与竞态条件的“隐藏”

有时，在某些操作系统（如windows）上运行上述代码时，可能会意外地得到0作为最终结果。这并非意味着竞态条件不存在，而是由于操作系统线程调度策略的偶然性。

现代操作系统的线程调度器会根据时间片、优先级等因素在不同线程之间切换CPU。在某些情况下，一个线程可能在另一个线程获得显著CPU时间之前，就完成了大部分甚至全部的循环迭代。例如，如果线程1在线程2开始大量执行前就完成了几乎所有加法操作，那么当线程2开始执行时，x的值已经非常大，然后线程2再执行几乎所有减法操作，最终结果可能恰好接近0，甚至偶然为0。

这种现象具有高度的非确定性，并且极度依赖于：

• 操作系统线程调度器： 不同操作系统、甚至同一操作系统的不同版本或不同负载下，调度行为都可能不同。
• CPU核心数量： 在单核CPU上，线程是分时复用的；在多核CPU上，线程可能真正并行执行。
• 程序运行时负载： 系统中运行的其他进程和线程会影响当前程序的调度。

因此，即使在特定环境下观察到正确结果，也绝不能将其视为线程安全的证据。这只是竞态条件在特定调度下未被显式暴露的假象。

使用threading.Barrier显式暴露竞态条件

为了更可靠地演示竞态条件，我们可以使用threading.Barrier同步原语。Barrier允许一组线程在某个同步点等待，直到所有线程都到达该点后，才一起继续执行。这有助于确保所有参与竞态的线程几乎同时开始它们的关键操作，从而增加竞态条件发生的概率。

清程爱画

ai图像与视频生成平台，拥有超丰富的工作流社区和多种图像生成模式。

44

查看详情

以下是使用Barrier改进后的示例代码：

import threading  # 创建一个屏障，等待2个线程 b = threading.Barrier(2, timeout=5)  x = 0;  class Thread1(threading.Thread):            def run(self):          global x         # 等待所有线程到达屏障         b.wait()          for i in range(int(1e5)): # 减少迭代次数以加快演示             x += i # 使用复合赋值运算符  class Thread2(threading.Thread):     def run(self):           global x         # 等待所有线程到达屏障         b.wait()         for i in range(int(1e5)): # 减少迭代次数             x -= i # 使用复合赋值运算符  t1 = Thread1() t2 = Thread2() t1.start() t2.start() t1.join() t2.join()  print("Sum is "+str(x));

在这个修改后的代码中：

1. b = threading.Barrier(2, timeout=5)创建了一个屏障，它会等待两个线程。timeout参数防止线程永久等待。
2. 在每个线程的run方法中，b.wait()调用会使线程暂停，直到另一个线程也调用了b.wait()。
3. 一旦两个线程都到达屏障，它们会同时被释放，几乎同时开始对x进行操作。
4. 我们将迭代次数减少到1e5（10万次），以更快地看到结果。
5. 使用了x += i和x -= i。虽然这些复合赋值操作在Python层面看似原子，但在底层，它们仍然是非原子的读-修改-写操作，且引入了i变量，使得每次操作的值不同，这可能会导致更大的最终偏差，从而更明显地展示竞态条件。

运行这段代码，你会发现x的值几乎总是非零的，从而明确地证实了竞态条件的存在。

解决竞态条件：同步机制

要真正解决竞态条件，确保共享资源的安全访问，我们需要使用适当的同步机制。Python的threading模块提供了多种同步原语：

• threading.Lock (互斥锁): 最基本的同步机制。它确保在任何给定时间只有一个线程可以访问被保护的代码段（临界区）。当一个线程获取锁后，其他试图获取同一把锁的线程将被阻塞，直到锁被释放。
• threading.RLock (可重入锁): 允许同一个线程多次获取同一把锁，但必须释放相同次数才能完全释放。
• threading.Semaphore (信号量): 用于控制对共享资源的并发访问数量。它可以允许N个线程同时访问资源。
• threading.Event (事件): 用于线程间的通信，一个线程可以发出信号，通知其他等待的线程继续执行。
• threading.Condition (条件变量): 通常与锁一起使用，允许线程在某个条件不满足时等待，并在条件满足时被唤醒。

对于上述增减x的例子，最常见的解决方案是使用threading.Lock：

import threading  x = 0 lock = threading.Lock() # 创建一个锁  class Thread1(threading.Thread):            def run(self):          global x         for i in range(1,1000000):             with lock: # 使用with语句确保锁的正确获取和释放                 x = x + 1  class Thread2(threading.Thread):     def run(self):           global x         for i in range(1,1000000):             with lock: # 使用with语句                 x = x - 1  t1 = Thread1() t2 = Thread2() t1.start() t2.start() t1.join() t2.join()  print("Sum is "+str(x));

通过with lock:语句，我们确保了对x的每次读-修改-写操作都是原子性的，即在同一时间只有一个线程能够执行x = x + 1或x = x – 1。运行这段代码，最终结果将始终为0。

总结

Python多线程编程中的竞态条件是一个常见且关键的问题。即使在某些特定环境下，非同步代码可能偶尔产生“正确”的结果，但这只是操作系统调度带来的偶然性，绝不能作为代码线程安全的依据。理解线程调度的非确定性，并学会使用threading.Barrier等工具来显式暴露竞态条件，对于诊断和解决并发问题至关重要。最终，为了确保多线程程序的正确性和数据一致性，开发者必须始终使用threading.Lock、Semaphore等适当的同步原语来保护共享资源的访问。