Python Condition：控制线程的“指挥家”

引言

在并发编程领域，Condition（条件变量）是一个非常重要的概念。它不仅能够帮助我们在复杂的多线程环境中实现线程间的同步，还能有效避免常见的线程安全问题如竞态条件等。通过使用Condition，我们可以轻松地实现生产者-消费者模式、信号量机制等多种并发设计模式。

基础语法介绍

什么是Condition？

在Python中，threading.Condition类提供了一种方法来管理多个线程对共享资源的访问。简单来说，它允许某个线程等待直到另一个线程执行特定操作后才继续执行。这在处理数据生产和消费过程中尤其有用，可以防止线程之间不必要的竞争。

如何创建Condition对象？

import threading

lock = threading.Lock()
condition = threading.Condition(lock)

这里，我们首先创建了一个锁对象lock，然后使用该锁初始化了一个Condition对象。注意，Condition对象必须关联一个锁对象，因为只有当线程获得了锁之后才能调用Condition的方法。

基础实例

让我们来看一个简单的例子，了解如何使用Condition来同步两个线程的执行。

问题描述

假设我们有一个任务队列，需要一个线程负责添加任务，而另一个线程负责处理这些任务。我们的目标是保证处理线程只在有新任务时才工作。

代码示例

import threading
import time

class Worker(threading.Thread):
    def __init__(self, condition):
        super().__init__()
        self.condition = condition

    def run(self):
        while True:
            with self.condition:
                self.condition.wait()  # 等待通知
                print("Task processed")
                time.sleep(0.5)

class Producer(threading.Thread):
    def __init__(self, condition):
        super().__init__()
        self.condition = condition

    def run(self):
        for _ in range(5):
            with self.condition:
                print("Adding task")
                self.condition.notify_all()  # 通知所有等待线程
                time.sleep(1)

condition = threading.Condition()
worker = Worker(condition)
producer = Producer(condition)

worker.start()
producer.start()

worker.join()
producer.join()

在这个例子中，Worker线程会一直等待直到接收到Producer线程的通知才会处理任务。这样就实现了两者的同步。

进阶实例

问题描述

在实际应用中，我们可能需要处理更复杂的情况，比如多个生产者和多个消费者，并且希望在队列为空或满时自动阻塞线程。

高级代码实例

import queue
import threading

class BoundedQueue:
    def __init__(self, maxsize):
        self.queue = queue.Queue(maxsize)
        self.lock = threading.Lock()
        self.condition = threading.Condition(self.lock)

    def put(self, item):
        with self.condition:
            while self.queue.full():
                self.condition.wait()
            self.queue.put(item)
            self.condition.notify_all()

    def get(self):
        with self.condition:
            while self.queue.empty():
                self.condition.wait()
            item = self.queue.get()
            self.condition.notify_all()
            return item

def producer(q):
    for i in range(10):
        q.put(i)
        print(f"Produced {i}")

def consumer(q):
    for _ in range(10):
        item = q.get()
        print(f"Consumed {item}")

q = BoundedQueue(5)

producer_thread = threading.Thread(target=producer, args=(q,))
consumer_thread = threading.Thread(target=consumer, args=(q,))

producer_thread.start()
consumer_thread.start()

producer_thread.join()
consumer_thread.join()

这段代码展示了如何使用Condition结合queue.Queue来构建一个有界队列，实现多个生产者和消费者的高效协作。

实战案例

问题描述

在某次项目中，我们需要开发一个多线程的数据处理系统，用于实时分析来自不同传感器的数据流。系统需要支持动态调整处理速度以适应网络波动，并且保证数据不会丢失。

解决方案与代码实现

为了满足需求，我们设计了一个基于Condition的框架，其中包含一个中央调度器和多个处理单元。调度器负责监控网络状态并调整各单元的工作节奏；处理单元则根据调度指令进行数据处理。

import threading
import random

class DataHandler(threading.Thread):
    def __init__(self, name, condition):
        super().__init__()
        self.name = name
        self.condition = condition

    def run(self):
        with self.condition:
            while True:
                self.condition.wait()  # 等待调度指令
                data = self.fetch_data()  # 模拟数据获取过程
                self.process(data)  # 处理数据
                print(f"{self.name} processed {data}")

class Dispatcher:
    def __init__(self, handlers):
        self.handlers = handlers
        self.condition = threading.Condition()

    def start(self):
        for handler in self.handlers:
            handler.start()

    def schedule(self):
        while True:
            with self.condition:
                speed = random.randint(1, 5)  # 模拟网络波动
                for handler in self.handlers:
                    handler.condition.notify()  # 通知所有处理器
                time.sleep(speed)

handlers = [DataHandler(f"Handler-{i}", threading.Condition()) for i in range(3)]
dispatcher = Dispatcher(handlers)

dispatcher.start()
dispatcher.schedule()

通过这种方式，我们成功实现了灵活的多线程数据处理系统，极大地提高了系统的响应速度和稳定性。

扩展讨论

虽然本文主要介绍了Condition的基本用法及其在多线程编程中的应用，但其实际用途远不止于此。例如，在分布式系统中，Condition可以用来实现更复杂的同步算法，如选举协议等。此外，对于那些对性能有更高要求的应用场景，还可以考虑使用multiprocessing模块提供的Condition对象来进行进程间通信。