Python异步编程核心速成

ftpeak

于 2025-02-04 14:38:42 发布

阅读量1.4k

点赞数 46

文章标签： python 开发语言

本文链接：https://blog.csdn.net/weixin_43033268/article/details/145440017

版权

异步的本质到底是什么？在这里，笔者以一个关于 Python asyncio 的极度简明的教程和示例，帮助你快速理解异步编程的核心概念和要点。

一、基础概念

协程 (Coroutine): 用 async def 定义的函数，可通过 await 暂停执行。
事件循环 (Event Loop): 异步任务调度器。
async/await: 定义协程和等待异步操作的关键字。

二、快速示例

示例 1: 最简单的协程

import asyncio

async def hello():
    print("Hello")
    await asyncio.sleep(1)  # 模拟耗时操作
    print("World")

# 运行协程
asyncio.run(hello())  # 输出: Hello -> (等待1秒) -> World

示例 2: 并发执行多个任务

import asyncio

async def task(name, delay):
    print(f"{name} started")
    await asyncio.sleep(delay)
    print(f"{name} finished")

async def main():
    # 创建任务并发执行
    task1 = asyncio.create_task(task("A", 2))
    task2 = asyncio.create_task(task("B", 1))
    
    await task1
    await task2

asyncio.run(main())

# 输出:
# A started
# B started
# B finished (1秒后)
# A finished (再等1秒)

示例 3: 同步 vs 异步耗时对比

import asyncio
import time

# 同步版本
def sync_demo():
    for i in range(3):
        time.sleep(1)

# 异步版本
async def async_demo():
    for _ in range(3):
        await asyncio.sleep(1)

# 时间测试
start = time.time()
sync_demo()
print(f"Sync: {time.time() - start:.2f}s")  # 约 3秒

start = time.time()
asyncio.run(async_demo())
print(f"Async: {time.time() - start:.2f}s")  # 约 1秒 (协程并发执行)

三、实际应用场景

示例 4: 异步HTTP请求

(需安装 aiohttp)

import aiohttp
import asyncio

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

async def main():
    urls = [
        "https://httpbin.org/get",
        "https://api.github.com",
        "https://example.com"
    ]
    
    # 并发请求
    tasks = [fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    for url, text in zip(urls, results):
        print(f"{url} -> {len(text)} bytes")

asyncio.run(main())

示例 5: 异步文件操作

(需安装 aiofiles)

import aiofiles
import asyncio

async def write_file():
    async with aiofiles.open('test.txt', 'w') as f:
        await f.write("Async file write!")

async def read_file():
    async with aiofiles.open('test.txt', 'r') as f:
        content = await f.read()
        print(content)

async def main():
    await write_file()
    await read_file()  # 输出: Async file write!

asyncio.run(main())

四、关键注意事项

避免阻塞操作：不要在协程中使用 time.sleep() 等阻塞函数，要用 await asyncio.sleep()
任务管理：使用 asyncio.create_task() 或 asyncio.gather() 管理并发
事件循环：Python 3.7+ 推荐使用 asyncio.run() 作为入口

五、异步编程的核心特性

1. 非阻塞 I/O 操作

特性：在等待 I/O 操作（如网络请求、文件读写、数据库查询）时，程序不会阻塞当前线程，而是将控制权交还给事件循环，允许其他任务继续执行。
示例：当一个 HTTP 请求等待服务器响应时，协程会释放 CPU 资源，让其他协程运行（如示例 4 中的并发 HTTP 请求）。

2. 单线程并发

特性：通过事件循环（Event Loop）在单线程内调度多个任务，无需依赖多线程或多进程，避免了线程切换的开销和锁竞争问题。
示例：示例 2 中，两个任务 A 和 B 在单线程内并发执行，通过 await 协作切换。

3. 协程（Coroutine）

特性：轻量级线程，通过 async/await 语法定义，可以在任意时刻暂停和恢复执行。协程的切换由开发者显式控制（通过 await），而非操作系统。
优势：相比线程，协程的创建和切换成本极低（微秒级），适合高并发场景。

4. 事件驱动模型

特性：事件循环监听并响应外部事件（如网络数据到达、文件读写完成），按优先级调度协程的执行。
关键机制：通过回调、Future 对象或 asyncio 的任务（Task）管理异步操作的完成状态。

六、异步编程的重要性

1. 高性能 I/O 密集型应用

场景：适用于需要处理大量并发连接的场景（如 Web 服务器、API 网关、爬虫）。
对比：
- 同步阻塞模型：每个请求占用一个线程/进程，资源消耗大（如示例 3 中的同步版本耗时 3 秒）。
- 异步非阻塞模型：单线程处理数千连接（如示例 3 中的异步版本耗时 1 秒）。

2. 资源高效利用

优势：避免线程/进程的频繁创建和切换，减少内存占用和 CPU 开销。
数据：一个线程的开销约为 1MB，而一个协程的开销仅为几 KB。

3. 高响应性

场景：对实时性要求高的应用（如聊天服务器、实时数据处理）。
机制：事件循环优先处理已就绪的任务，减少等待时间。

4. 简化并发编程

优势：通过 async/await 语法，以同步代码的风格编写异步逻辑，避免回调地狱（Callback Hell）。
对比：
- 回调模式：嵌套回调难以维护（如传统 JavaScript）。
- 协程模式：线性代码结构（如示例 2 中的 main 函数）。

5. 可扩展性

场景：轻松扩展到数万并发连接（如微服务架构中的网关服务）。
工具支持：Python 生态中的 aiohttp、asyncpg、FastAPI 等库提供异步支持。

七、异步编程的适用场景

场景类型	示例	异步的优势
高并发 I/O 密集型	Web 服务器、API 服务、爬虫	单线程处理数千连接，资源消耗低
实时应用	聊天室、游戏服务器、物联网	快速响应事件，避免延迟
批处理任务	批量文件处理、数据清洗	并发执行任务，缩短总耗时
微服务架构	服务间通信（RPC、消息队列）	高效管理多个服务的异步交互

八、异步编程的局限性

不适用于 CPU 密集型任务
- 异步模型的优势在于 I/O 等待期间的资源释放，但 CPU 密集型任务（如复杂计算）会阻塞事件循环。也就是说，对于任何需要大量计算、数据处理、复杂算法的操作都属于这一类（数学计算、图像处理、数据加密解密、科学模拟等）异步编程并不能有效的提高整体效率，例如：数值计算（如循环计算、大数阶乘）、图像处理（Pillow库处理图片）、数据序列化（JSON的序列化与反序列化）、加密解密（使用hashlib或cryptography库）、机器学习模型训练（TensorFlow、PyTorch）、压缩解压（zlib、gzip）、字符串处理（大规模正则匹配）、复杂算法（排序、搜索、动态规划）以及科学计算（NumPy、SciPy中的某些操作）。
- 解决方案：结合多进程（如 multiprocessing）或专用计算线程。
代码复杂度增加
- 需要显式管理 async/await，避免误用同步阻塞函数（如误用 time.sleep() 代替 asyncio.sleep()）。
- 调试难度：异步代码的调用栈和异常处理更复杂。
生态依赖
- 许多库需要专门的异步版本（如 aiohttp 替代 requests，asyncpg 替代 psycopg2）。