Python线程同步：条件变量中wait()方法为何需要while循环

在使用python的条件变量（`condition`）进行线程同步时，`wait()`方法通常需要在一个`while`循环中调用，而非简单的`if`语句。这是为了防止“虚假唤醒”以及在`wait()`释放锁到重新获取锁期间，其他线程可能已经改变了条件状态，导致当前线程即使被唤醒也无法满足执行条件。`while`循环确保每次从`wait()`返回时都会重新检查条件，从而保证程序的正确性和健壮性。

在多线程编程中，条件变量（Condition）是实现线程间协同工作的重要机制。它允许一个线程在某个条件不满足时暂停执行（等待），直到另一个线程改变了条件并发出通知（唤醒）。然而，在使用Condition.wait()方法时，一个常见的疑问是：为什么等待条件需要用while循环来检查，而不是简单的if语句？

理解条件变量的工作原理

首先，我们通过一个经典的生产者-消费者模型来引入这个问题。假设有一个共享的money变量，生产者线程向其中增加金额，消费者线程从中取出金额，但消费者必须确保money不为负数。

以下是原始代码示例：

from threading import Thread, Condition

condition = Condition()
money = 0

def producer():
    global money
    for _ in range(1000000):
        condition.acquire() # 获取条件变量的锁
        money += 10
        print(f"Producer added 10, money = {money}")
        condition.notify()  # 通知一个等待的线程
        condition.release() # 释放条件变量的锁

def consumer():
    global money
    for _ in range(500000):
        condition.acquire() # 获取条件变量的锁
        # 疑问点：这里应该用 if 还是 while？
        if money < 0: # 假设这里使用了 if
            condition.wait() # 释放锁并等待通知
        money -= 20
        print(f"Consumer spent 20, money = {money}")
        condition.release() # 释放条件变量的锁


if __name__ == "__main__":

    t1 = Thread(target=producer, args=())
    t2 = Thread(target=consumer, args=())

    t1.start()
    t2.start()

    t1.join()
    t2.join()

在这个消费者线程中，if money < 0: 后面跟着 condition.wait()。直观来看，当money不足时，消费者等待；当生产者增加money并通知后，消费者被唤醒，然后继续执行。这似乎是合理的，但实际上存在潜在的问题。

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

condition.wait()的潜在风险

condition.wait()方法的行为比初看起来要复杂一些。当一个线程调用wait()时，它会执行以下操作：

vizcom.ai

AI草图渲染工具，快速将手绘草图渲染成精美的图像

139

查看详情

1. 原子性地释放它所持有的锁。
2. 进入阻塞状态，等待被notify()或notify_all()唤醒。
3. 被唤醒后，它会尝试重新获取之前释放的锁。
4. 成功获取锁后，wait()方法返回。

问题就出在第3步和第4步之间，以及wait()本身的特性：

1. 虚假唤醒（Spurious Wakeups）：根据并发编程规范，wait()方法有时可能会在没有收到notify()或notify_all()调用的情况下返回（即“虚假唤醒”）。虽然在Python的threading模块中，这种情况不常见，但作为一种通用的并发编程模式，必须考虑到。
2. 条件在唤醒与重获锁之间改变：这是更常见且更重要的原因。考虑以下场景：
   • 消费者线程A获取锁，检查发现money < 0，于是调用condition.wait()。锁被释放，线程A进入等待。
   • 生产者线程B获取锁，增加money，然后调用condition.notify()，释放锁。
   • 此时，线程A被唤醒，但它需要重新获取锁才能继续执行。
   • 在线程A重新获取锁之前，可能有另一个消费者线程C抢先获取了锁。线程C执行，它也发现money满足条件（或者它不需要等待），并消耗了money，甚至可能导致money再次变为负数，然后释放锁。
   • 最终，线程A成功获取了锁，wait()方法返回。如果此时线程A使用的是if money < 0:，它只会检查一次。由于它已经被“唤醒”，if条件可能不再满足（因为money可能已经被其他线程消耗），它会直接跳过wait()，继续执行money -= 20，这可能导致money变为一个比预期更小的负数，从而破坏了业务逻辑的完整性。

while循环的必要性

为了解决上述问题，正确的做法是使用while循环来包裹condition.wait()：

from threading import Thread, Condition

condition = Condition()
money = 0

def producer():
    global money
    for _ in range(1000000):
        condition.acquire()
        money += 10
        # print(f"Producer added 10, money = {money}") # 减少打印，避免性能瓶颈
        condition.notify()
        condition.release()

def consumer():
    global money
    for _ in range(500000):
        condition.acquire()
        # 关键改进：使用 while 循环
        while money < 20: # 假设消费需要20，所以需要money至少为20
            # print(f"Consumer waiting, money = {money}") # 减少打印
            condition.wait() # 释放锁并等待通知
        money -= 20
        # print(f"Consumer spent 20, money = {money}") # 减少打印
        condition.release()


if __name__ == "__main__":

    t1 = Thread(target=producer, args=())
    t2 = Thread(target=consumer, args=())

    t1.start()
    t2.start()

    t1.join()
    t2.join()
    print(f"Final money: {money}") # 打印最终金额

在修正后的消费者代码中，while money < 20: 确保了以下几点：

1. 条件重检：无论wait()是由于虚假唤醒还是真正的notify()而返回，while循环都会在线程重新获取锁后再次检查money是否满足条件。
2. 防止不安全操作：如果条件在线程等待期间被其他线程改变，导致当前线程被唤醒时条件已不再满足，while循环会再次调用wait()，使线程继续等待，直到条件真正满足为止。这保证了在执行money -= 20之前，money变量确实处于一个安全可操作的状态。

总结与最佳实践

使用while循环检查条件是条件变量同步机制中的一项基本且至关重要的最佳实践。它能够有效地：

• 处理虚假唤醒：虽然Python中不常见，但遵循此模式可确保跨平台和语言的健壮性。
• 防止竞态条件：避免因其他线程在等待线程被唤醒到重新获取锁期间修改共享状态而导致的逻辑错误。
• 确保条件满足：保证只有当线程所依赖的条件真正满足时，它才会继续执行后续操作，从而维护程序的正确性。

因此，无论何时使用condition.wait()，都应将其放置在一个while循环中，以确保线程在继续执行前，总是重新验证其等待的条件是否仍然成立。这是编写安全、可靠多线程程序的关键。

以上就是Python线程同步：条件变量中wait()方法为何需要while循环的详细内容，更多请关注php中文网其它相关文章！