Python异步编程入门：从同步到异步的思维转变-CSDN博客

本文链接：https://blog.csdn.net/qq_16226939/article/details/147724502

引言

作为一名开发者，你可能已经习惯了传统的同步编程模式——代码一行接一行地执行，每个操作都等待前一个操作完成。但在I/O密集型应用中，这种模式会导致大量时间浪费在等待上。今天，我们将探讨Python中的异步编程，这是一种可以显著提高程序效率的编程范式。

同步 vs 异步

同步代码示例

import time

def fetch_data():
    print("开始获取数据...")
    time.sleep(2)  # 模拟I/O操作
    print("数据获取完成")
    return {"data": 42}

def process_data():
    data = fetch_data()
    print(f"处理数据: {data['data'] * 2}")
    time.sleep(1)  # 模拟CPU处理
    print("数据处理完成")

start = time.time()
process_data()
process_data()
print(f"总耗时: {time.time() - start:.2f}秒")

输出：

开始获取数据...
数据获取完成
处理数据: 84
数据处理完成
开始获取数据...
数据获取完成
处理数据: 84
数据处理完成
总耗时: 6.02秒

异步代码示例

import asyncio
import time

async def fetch_data():
    print("开始获取数据...")
    await asyncio.sleep(2)  # 模拟异步I/O操作
    print("数据获取完成")
    return {"data": 42}

async def process_data():
    data = await fetch_data()
    print(f"处理数据: {data['data'] * 2}")
    await asyncio.sleep(1)  # 模拟异步CPU处理
    print("数据处理完成")

async def main():
    start = time.time()
    await asyncio.gather(process_data(), process_data())
    print(f"总耗时: {time.time() - start:.2f}秒")

asyncio.run(main())

输出：

开始获取数据...
开始获取数据...
数据获取完成
数据获取完成
处理数据: 84
处理数据: 84
数据处理完成
数据处理完成
总耗时: 3.01秒

关键概念解析

1. 协程 (Coroutine)

协程是异步编程的基本单位，使用async def定义的函数就是协程：

async def my_coroutine():
    await some_async_operation()

2. 事件循环 (Event Loop)

事件循环是异步编程的核心，它负责调度和执行协程：

loop = asyncio.get_event_loop()
loop.run_until_complete(my_coroutine())

3. await表达式

await用于暂停当前协程的执行，直到等待的操作完成：

result = await some_async_function()

实际应用示例：异步HTTP请求

import aiohttp
import asyncio

async def fetch_url(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = [
        'https://python.org',
        'https://github.com',
        'https://stackoverflow.com'
    ]
    
    tasks = [fetch_url(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    for url, content in zip(urls, results):
        print(f"{url}: {len(content)} bytes")

asyncio.run(main())

性能对比

让我们比较同步和异步方式获取多个网页的性能：

import requests
import time

def sync_fetch(url):
    return requests.get(url).text

def sync_main():
    urls = [...]  # 多个URL
    start = time.time()
    for url in urls:
        sync_fetch(url)
    print(f"同步耗时: {time.time() - start:.2f}秒")

async def async_main():
    urls = [...]  # 同上
    start = time.time()
    await asyncio.gather(*[fetch_url(url) for url in urls])
    print(f"异步耗时: {time.time() - start:.2f}秒")

在实际测试中，异步版本通常比同步版本快5-10倍！

常见陷阱与最佳实践

不要混用同步和异步代码：在协程中调用同步I/O操作会阻塞整个事件循环
合理使用asyncio.gather：并行执行多个协程
设置适当的超时：使用asyncio.wait_for避免无限等待

错误处理：协程中的异常需要用try/except捕获

async def safe_fetch(url):
    try:
        return await fetch_url(url)
    except aiohttp.ClientError as e:
        print(f"请求失败: {e}")
        return None