Python并发编程详解：从协程到asyncio实战

Noah

发布时间：2026-10-12 | 2人浏览过

原创

本文深入解析Python并发编程核心概念，详细对比协程、线程与进程的区别。通过Greenlet、Gevent及asyncio库的实战代码，演示任务切换、IO阻塞处理及事件循环机制，帮助开发者掌握高并发场景下的性能优化方案。

一、协程定义和作用

协程（coroutine），也被称为微线程或纤程。它是一种用户态的轻量级线程，允许程序在单线程内实现非抢占式的并发执行。

其核心作用在于：当执行函数 A 时，可以随时中断并切换到执行函数 B，随后再返回继续执行 A。这种切换是自动进行的，并非通过传统的函数调用语句实现。虽然行为类似多线程，但协程仅占用一个线程资源。

1、使用协程的优点

由于协程自带上下文和栈，无需操作系统进行线程上下文切换，开销极小。这种切换发生在程序层面，操作系统无法感知，因此更加轻量级。

无需原子操作的锁定及同步开销，减少了并发控制的复杂性。

方便切换控制流，从而简化编程模型，使代码逻辑更清晰。

单线程内即可实现并发效果，最大限度地利用 CPU 资源，且具备高可扩展性和低成本优势。注：一个 CPU 支持上万的协程并非难题，因此协程非常适合用于高并发处理场景。

2、使用协程的缺点

无法直接利用多核资源：协程本质上是单线程的，不能同时将单个 CPU 的多个核心并行使用。若需运行在多 CPU 上，必须与进程配合。当然，日常编写的绝大部分应用无需此功能，除非是 CPU 密集型应用。

进行阻塞（Blocking）操作（如 IO 读写时）会阻塞掉整个程序，导致其他协程无法执行。

# 协程的基本使用，  实现两个任务的切换         yield  和 next 来回切换
def func1():
    for i in range(11):
        print(f"一班打印第{i}次数据")
        yield
def func2():
    g = func1()
    next(g)
    for i in range(10):
        print(f"二班打印第{i}次数据")
        next(g)
if __name__ == "__main__":
    func2()

二、Greenlet 的使用

在单线程内管理多个任务时，可以使用 greenlet 实现任务的切换。greenlet 和 switch 方法组合使用，可手动控制协程间的执行流。

from greenlet import greenlet
# pip install greenlet
def gf(name):
    print(f'{name}:我想王者！！')
    g2.switch('zf')
    print(f'{name}:我想吃大餐！！！')
    g2.switch()
def bf(name):
    print(f'{name}:一块去完！！！')
    g1.switch()
    print(f'{name}:一起去吃！！')
if __name__ == "__main__":
    g1 = greenlet(gf)
    g2 = greenlet(bf)
    # 切换任务
    g1.switch('dc')   # 只需要第一次上传

三、Gevent的使用

Gevent 是一个第三方库，通过 gevent 模块可以轻松实现并发同步或异步编程。在 gevent 中，主要模式是 Greenlet，它以 C 扩展模块的形式接入 Python，提供轻量级协程支持。

Greenlet 全部运行在主程序操作系统进程的内部，但它们被协作式地调度，即由程序主动让出控制权。

from gevent import monkey; # 为了能识别time模块的io
monkey.patch_all()  #必须放到被打补丁者的前面，如 time，socket 模块之前
import gevent
# pip install gevent
from time import time,sleep
def gf(name):
    print(f'{name}:我想打王者！！')
    # gevent.sleep(2)
    sleep(2)
    print(f'{name}:我想吃大餐！！！')
def bf(name):
    print(f'{name}:一起打！！！')
    # gevent.sleep(2)
    sleep(2)
    print(f'{name}:一快去吃！！')
if __name__ == "__main__":
    start = time()
    # 创建协程对象
    g1 = gevent.spawn(gf,'貂蝉')
    g2 = gevent.spawn(bf,'吕布')
    # 开启任务
    g1.join()
    g2.join()
    end = time()
    print(end-start)

注意：上例中 gevent.sleep(2) 模拟的是 gevent 可以识别的 IO 阻塞；而 time.sleep(2) 或其他标准库阻塞，gevent 不能直接识别。此时需要使用 monkey.patch_all() 打补丁，即可让 gevent 识别这些阻塞操作。

四、async io 异步 IO

asyncio 是 python3.4 之后的协程模块，也是 Python 实现并发的重要包。该包使用事件循环驱动来实现并发操作。

事件循环是一种处理多并发量的有效方式，在维基百科中它被描述为「一种等待程序分配事件或消息的编程架构」。我们可以定义事件循环来简化使用轮询方法来监控事件，通俗的说法就是「当 A 发生时，执行 B」。

@asyncio.coroutine 协程装饰器装饰
asyncio.sleep() 可以避免事件循环阻塞
get_event_loop() 获取事件循环
Loop.run_until_complete() 监听事件循环
gather() 封装任务
await 等于 yield from 就是在等待 task 结果

import asyncio
@asyncio.coroutine # python3.5 之前 官网说3.10将被移除
def func1():
    for i in range(5):
        print('一边吃饭！！')
        yield from asyncio.sleep(0)
async def func2(): # python3.5以上
    for i in range(5):
        print('一边打游戏！！！')
        await asyncio.sleep(0)
if __name__ == "__main__":
    g1 = func1()
    g2 = func2()
    # 获取事件循环
    loop = asyncio.get_event_loop()
    # 监听事件循环
    loop.run_until_complete(asyncio.gather(g1,g2))
    # 关闭事件循环
    loop.close()

1、asyncio中的task的使用

import asyncio
import functools
async def compute(x,y):
    print(f'compute:{x}+{y}....')
    await asyncio.sleep(1)
    return x+y
async def print_sum(x,y):
    # 创建task
    task = asyncio.create_task(compute(x,y))        #python3.7以上写法
    # task绑定回调函数
    task.add_done_callback(functools.partial(end,x,y))  #python3.7以上写法
    # 释放下cpu的使用
    await asyncio.sleep(0)
    print('--------------------print_num继续执行---------------------------')
    for i in range(1000000):
        if i%5000 ==0:
            print(i)
            await asyncio.sleep(0.1)
def end(n,m,t):
    print(f'{n}+{m}={t.result()}')
if __name__ == "__main__":
    loop = asyncio.get_event_loop()
    loop.run_until_complete(print_sum(1,2))
    loop.close()