引言
在并发编程领域，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对象来进行进程间通信。
