38、Python协程与任务调度高级技巧：从异步IO到分布式实践

最新推荐文章于 2025-04-29 15:28:57 发布

wolf犭良

最新推荐文章于 2025-04-29 15:28:57 发布

阅读量387

点赞数 3

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/ldz_wolf/article/details/147573067

版权

python 专栏收录该内容

49 篇文章

订阅专栏

Python协程与任务调度高级技巧：从异步IO到分布式实践

引言

在Python异步编程领域，asyncio库的协程与任务调度机制是构建高性能应用的核心。本文将深入探讨任务生命周期管理、调度策略优化等进阶主题，通过典型场景案例和性能对比数据，揭示异步编程在IO密集型系统中的实践精髓。文章包含大量可直接用于生产环境的代码示例，并附带调试技巧与最佳实践建议。

一、任务生命周期全解析

1.1 安全取消任务

async def worker():
    try:
        while True:
            await asyncio.sleep(1)
            print("Working...")
    except asyncio.CancelledError:
        print("Cleanup resources")
        raise

async def main():
    task = asyncio.create_task(worker())
    await asyncio.sleep(2.5)
    task.cancel()
    try:
        await task
    except asyncio.CancelledError:
        print("Task cancelled successfully")

asyncio.run(main())

代码说明：

使用task.cancel()触发取消请求
协程内捕获CancelledError执行清理操作
必须await被取消的任务才能完成取消流程

注意事项：

被shield保护的任务段无法被取消
取消操作具有传播性，子任务也会被级联取消
推荐使用asyncio.timeout()上下文管理器实现安全取消

1.2 超时控制策略

async def fetch_data():
    await asyncio.sleep(3)  # 模拟耗时操作
    return "data"

async def main():
    try:
        # 方式1：使用wait_for
        result = await asyncio.wait_for(fetch_data(), timeout=2)
    except TimeoutError:
        print("Request timed out")

    # 方式2：使用wait
    task = asyncio.create_task(fetch_data())
    done, pending = await asyncio.wait([task], timeout=2)
    if pending:
        task.cancel()
        print("Terminated pending task")

策略对比：

方法	返回值处理	自动取消	适用场景
wait_for	直接返回	自动	简单超时控制
wait	需手动处理	手动	批量任务管理
asyncio.timeout	上下文管理	自动	资源精确释放

二、高级调度策略实现

2.1 优先级调度引擎

from heapq import heappush, heappop

class PriorityScheduler:
    def __init__(self):
        self._ready = []
        self._time = 0
        self._counter = 0

    def add_task(self, coro, priority):
        heappush(self._ready, (priority, self._counter, coro))
        self._counter += 1

    async def run(self):
        while self._ready:
            priority, _, coro = heappop(self._ready)
            try:
                await coro
            except Exception as e:
                print(f"Task failed: {e}")

# 使用示例
scheduler = PriorityScheduler()
scheduler.add_task(task1, priority=1)
scheduler.add_task(task2, priority=5)
await scheduler.run()

2.2 权重轮询调度算法

class WeightedRoundRobin:
    def __init__(self):
        self.tasks = []
        self.weights = []
        self.current = -1
        self.gcd = None

    def add_task(self, task, weight):
        self.tasks.append(task)
        self.weights.append(weight)
        self.gcd = self._compute_gcd()

    def _compute_gcd(self):
        # 计算所有权重的最大公约数
        ...

    def __aiter__(self):
        return self

    async def __anext__(self):
        while True:
            self.current = (self.current + 1) % len(self.tasks)
            if self.weights[self.current] >= self.gcd:
                self.weights[self.current] -= self.gcd
                return self.tasks[self.current]

三、分布式任务队列实践

3.1 核心代码实现

class DistributedWorker:
    def __init__(self, redis_conn):
        self.redis = redis_conn
        self.local_queue = asyncio.Queue()
        self.pubsub = self.redis.pubsub()

    async def start(self):
        asyncio.create_task(self._pull_tasks())
        asyncio.create_task(self._process_local_queue())

    async def _pull_tasks(self):
        while True:
            # 从Redis获取批量任务
            tasks = await self.redis.lrange('task_queue', 0, 9)
            if tasks:
                await self.redis.ltrim('task_queue', 10, -1)
                for task in tasks:
                    await self.local_queue.put(task)
            else:
                await asyncio.sleep(0.1)

    async def _process_local_queue(self):
        while True:
            task_data = await self.local_queue.get()
            try:
                result = await self._execute_task(task_data)
                await self._store_result(task_data['id'], result)
            except Exception as e:
                await self._store_error(task_data['id'], str(e))

    async def _execute_task(self, data):
        # 任务执行逻辑
        ...

四、调试与监控技巧

4.1 协程堆栈追踪

def debug_coroutines():
    for task in asyncio.all_tasks():
        print(f"Task {task.get_name()}:")
        task.print_stack()

4.2 实时监控仪表盘

async def monitor_dashboard():
    while True:
        tasks = asyncio.all_tasks()
        running = sum(1 for t in tasks if t._state == 'PENDING')
        print(f"Active tasks: {running}")
        await asyncio.sleep(1)