在异步编程中，我们经常需要在后台执行耗时操作，以避免阻塞主程序的运行。python 的 asyncio 库提供了强大的协程和事件循环机制来实现这一目标。然而，当多个相同的后台任务可能并发执行时，有时我们需要确保这些任务按照特定顺序或一次只运行一个实例，以避免资源冲突或数据混乱。
考虑一个常见场景：应用程序持续收集数据，并在每个批次收集完成后将其保存。为了提高效率，数据保存操作被设计为后台任务。但如果数据收集速度快于数据保存速度，或者批次大小差异大，可能导致新的保存任务在旧的保存任务完成之前就开始执行，从而引发问题。例如，当 save_data() 协程被多次并发调用时，我们希望它能像单例模式一样，确保前一个保存操作完成后，下一个才能开始。
import asyncio
import random
async def save_data():
"""模拟数据保存操作"""
print("我正在保存一个批次的数据...")
await asyncio.sleep(2) # 模拟IO耗时
print("一个批次的数据保存完成。")
async def collect_data_problematic():
"""存在并发保存问题的示例"""
event_loop = asyncio.get_event_loop()
while True:
print("我正在收集数据...")
await asyncio.sleep(random.randint(1, 5)) # 模拟数据收集耗时
# 直接创建任务，可能导致多个save_data并发运行
event_loop.create_task(save_data())
# asyncio.run(collect_data_problematic())上述代码中，save_data() 可能会被多次并发调用，导致数据保存逻辑混乱。为了解决这个问题，我们可以采用以下两种策略。
策略一：等待前一个任务完成（阻塞式协调）
这种方法的核心思想是：在启动新的后台任务之前，先检查是否存在一个正在运行的同类型任务。如果存在，则等待它完成。这类似于双缓冲机制，确保每次只有一个保存任务在活动。
import asyncio
import random
async def save_data():
"""模拟数据保存操作"""
print("我正在保存一个批次的数据...")
await asyncio.sleep(2) # 模拟IO耗时
print("一个批次的数据保存完成。")
async def collect_data_await_previous():
"""通过等待前一个任务完成来协调"""
event_loop = asyncio.get_event_loop()
last_save_task = None # 用于跟踪上一个保存任务
while True:
print("我正在收集数据...")
await asyncio.sleep(random.randint(1, 5)) # 模拟数据收集耗时
if last_save_task: # 如果存在上一个保存任务
print("等待上一个保存任务完成...")
await last_save_task # 阻塞直到上一个保存任务完成
print("上一个保存任务已完成，可以开始新的保存。")
# 启动新的保存任务并更新last_save_task
last_save_task = event_loop.create_task(save_data())
# 循环结束后，确保最后一个保存任务也完成
if last_save_task:
await last_save_task
# 运行示例
# asyncio.run(collect_data_await_previous())优点：
立即学习“Python免费学习笔记（深入）”；
- 简单直观： 实现逻辑相对简单，易于理解。
- 顺序保证： 严格保证了 save_data 任务的顺序执行，不会出现重叠。
缺点：
- 性能瓶颈： 如果数据收集速度远快于数据保存速度，或者保存任务耗时很长，collect_data_await_previous 协程会被 await last_save_task 阻塞，导致数据收集也停滞，影响整体吞吐量。这使得并发优势部分丧失。
- 不适用于多任务队列： 无法在后台排队处理多个待保存批次。
策略二：使用 asyncio.Queue 实现解耦（生产者-消费者模式）
为了解决阻塞问题并提高并发效率，同时仍保证保存任务的顺序性，我们可以采用生产者-消费者模式，利用 asyncio.Queue 来解耦数据收集和数据保存过程。数据收集器作为生产者，将待保存的数据批次放入队列；一个或多个消费者（这里我们只用一个，以保证顺序）从队列中取出数据并执行保存操作。
import asyncio
import random
async def save_data_batch(batch_data):
"""模拟数据保存操作，接受批次数据"""
print(f"我正在保存批次: {batch_data}...")
await asyncio.sleep(2) # 模拟IO耗时
print(f"批次: {batch_data} 保存完成。")
async def collect_data_with_queue():
"""使用asyncio.Queue协调数据收集与保存"""
event_loop = asyncio.get_event_loop()
# 创建一个有最大容量的队列，防止内存耗尽
# maxsize=16 表示队列最多能存储16个待处理的批次
queue = asyncio.Queue(maxsize=16)
async def save_all_batches():
"""消费者协程：从队列中取出数据并保存"""
while True:
try:
batch = await queue.get() # 等待并获取一个批次
await save_data_batch(batch) # 执行保存操作
queue.task_done() # 标记该任务已完成
except asyncio.CancelledError:
# 协程被取消时退出循环，实现优雅关闭
print("保存任务被取消，退出。")
break
except Exception as e:
print(f"保存任务发生错误: {e}")
queue.task_done() # 即使出错也要标记完成，防止queue.join()死锁
# 启动后台保存任务
saving_task = event_loop.create_task(save_all_batches())
batch_counter = 0
while True:
print("我正在收集数据...")
await asyncio.sleep(random.randint(1, 5)) # 模拟数据收集耗时
batch_counter += 1
batch_data = f"Batch-{batch_counter}" # 模拟收集到的数据批次
# 将数据放入队列，如果队列满则等待
print(f"将 {batch_data} 放入队列...")
await queue.put(batch_data)
print(f"{batch_data} 已放入队列。")
# 优雅关闭：等待所有队列中的任务完成，然后取消保存任务
# 注意：实际应用中，通常会有一个外部信号来触发退出循环
# await queue.join() # 等待所有放入队列的任务被处理
# saving_task.cancel() # 取消后台保存任务
# await saving_task # 确保取消操作完成优点：
立即学习“Python免费学习笔记（深入）”；
- 高吞吐量： 数据收集和数据保存可以并发进行，互不阻塞，只要队列不满，收集器就可以持续工作。
- 解耦： 生产者和消费者之间通过队列完全解耦，提高了模块的独立性。
- 流量控制： maxsize 参数可以限制队列的内存占用，防止收集速度过快导致内存耗尽（背压机制）。
- 顺序保证： 尽管是并发的，但由于只有一个消费者 save_all_batches 实例从队列中取数据，因此保存操作仍然是严格顺序的。
缺点及注意事项：
- 复杂度增加： 相较于第一种方法，需要管理队列、消费者协程以及更复杂的错误处理和优雅关闭逻辑。
- 死锁风险： 如果消费者协程 save_all_batches 因异常退出，而 queue.task_done() 未被调用，或者 queue.join() 被调用时队列中仍有未处理的任务，可能导致 queue.join() 永久等待，造成死锁。因此，在 try...except 块中确保 queue.task_done() 被调用至关重要。
- 优雅关闭： 实际应用中，需要一个机制来停止 collect_data_with_queue 的无限循环，并在程序退出前确保所有队列中的数据都被保存。这通常涉及捕获信号或使用事件标志来协调协程的退出。
总结与选择
选择哪种策略取决于具体的应用场景和性能需求：
-
选择策略一（等待前一个任务完成）：
- 当需要严格控制并发实例数量，且允许主流程在后台任务完成时短暂暂停时。
- 当后台任务的执行频率不高，或者其耗时相对较短，不会对主流程造成明显阻塞时。
- 追求代码实现简洁性时。
-
选择策略二（使用 asyncio.Queue）：
- 当数据收集和处理流程需要高度解耦，以实现最大化吞吐量时。
- 当后台任务可能耗时较长，且希望主流程（如数据收集）尽可能不被阻塞时。
- 需要实现背压机制，防止系统过载时。
- 愿意接受更高的代码复杂度，以换取更好的并发性能和系统健壮性。
在大多数需要高并发和高吞吐量的 asyncio 应用中，使用 asyncio.Queue 的生产者-消费者模式是更推荐的方案，因为它提供了更灵活的并发控制和更强的系统韧性。但无论选择哪种方法，都应仔细考虑错误处理和程序的优雅关闭，以确保系统的稳定运行。
