操作系统 / 技术文章

为什么协程比线程轻量

协程通常可以在等待期间只保存恢复执行所需的状态,由运行时把同一个操作系统线程交给其他任务。大量任务同时等网络或定时器时,这种复用可以减少线程栈、内核调度对象和就绪线程的数量。收益取决于运行时、等待方式和每项任务保留的数据。

线程成本可以怎样观察

操作系统线程通常有独立的用户态栈和由内核管理的调度状态。栈预留占用虚拟地址空间,实际触及的内存页才可能计入驻留内存。进程的虚拟大小和驻留大小还包含堆、库及其他映射,因而不能直接用两者的变化推算每个线程的栈大小。

在 Linux 上运行下面的 Python 代码,可观察八个工作线程等待事件时的线程数和内存统计。Event 确保主线程读取数据时工作线程还存活。

python
from pathlib import Path
from threading import Event, Thread

def snapshot(label):
    status = Path("/proc/self/status").read_text().splitlines()
    keys = ("Threads:", "VmSize:", "VmRSS:")
    print(label, *(line for line in status if line.startswith(keys)), sep="\n")
    return int(next(line.split()[1] for line in status if line.startswith("Threads:")))

before = snapshot("创建前")
finish = Event()
workers = [Thread(target=finish.wait) for _ in range(8)]
for worker in workers:
    worker.start()
try:
    assert snapshot("八个工作线程等待时") == before + 8
finally:
    finish.set()
    for worker in workers:
        worker.join()

Threads 应增加 8,内存统计则随系统和运行环境变化。现代 Linux 的 /proc/<pid>/maps 中,[stack] 标识初始线程栈。旧内核曾提供的 [stack:tid] 自 Linux 4.5 移除,因此统计这类标签不能得到当前工作线程数。

运行时怎样承载协程

在 Python 的 asyncio 中,一个事件循环通常在一个线程上执行。Task 等待尚未完成的 Future 时,事件循环就能运行其他任务或处理 I/O。调用异步函数会先产生协程对象。直接 await 一个已经就绪的操作不一定让出执行权,需要并发安排任务时可使用 TaskGroup 或 create_task。

协程暂停时需要保存局部状态和恢复位置,具体内存布局由实现决定。编译器可以把异步函数变成状态机,运行时也可以用可增长的栈。Go 的 goroutine 用较小的初始栈并可按需增长,调度器把多个 goroutine 复用到多个系统线程上。它和单个 asyncio 事件循环的阻塞及并行行为不同。协程保留的大对象、缓冲区和未完成请求也会占用内存。

为什么切换通常更轻

线程切换由内核调度,涉及保存并恢复寄存器等执行上下文,还可能带来缓存局部性变化。同一进程的线程共享地址空间,不能把每次线程切换都算成进程地址空间切换。两个协程如果在同一个线程中先后执行,运行时可以在用户态从一个已暂停任务转到另一个就绪任务,期间可能无需发生内核线程切换。整个系统仍由内核提供线程调度和 I/O 就绪通知。

实测同步阻塞怎样影响事件循环

同一个事件循环中,先用事件通知观察任务,再让工作任务等待。异步等待和线程卸载会让观察任务先运行。同步睡眠让事件循环线程卡住,观察任务只能在睡眠结束后运行。

python
import asyncio
import time

async def trial(mode):
    ready = asyncio.Event()
    order = []

    async def observe():
        await ready.wait()
        order.append("观察任务运行")

    async def work():
        ready.set()
        if mode == "异步等待":
            await asyncio.sleep(0.05)
        elif mode == "同步阻塞":
            time.sleep(0.05)
        else:
            await asyncio.to_thread(time.sleep, 0.05)
        order.append("等待结束")

    await asyncio.gather(observe(), work())
    return order

async def main():
    for mode in ("异步等待", "同步阻塞", "卸载到线程"):
        order = await trial(mode)
        expected = ["观察任务运行", "等待结束"]
        if mode == "同步阻塞":
            expected.reverse()
        assert order == expected
        print(mode, " → ".join(order))

asyncio.run(main())

此处 asyncio.sleep 用定时器模拟可挂起等待。真实网络场景要确认客户端库提供能挂起的 I/O。to_thread 适合把部分阻塞 I/O 移出事件循环,但线程仍被占用,调用并发量需要控制。长时间纯计算同样会占住事件循环,是否可以跨核并行取决于运行时和执行方式。

按任务性质选择

大量连接长期处于等待状态,且协议栈和数据库驱动支持异步 I/O 时,协程通常能用较少线程承载更多连接。只有少量并发或者库主要提供同步接口时,有界线程池可以提供更直接的调用流程。CPU 密集型工作则要单独判断多核并行方式,例如适合所用语言的线程、进程或原生计算库。

比较两种设计时,固定负载和并发限制,再看吞吐、尾延迟、驻留内存和排队长度。异步服务还可以记录事件循环延迟与连接池等待时间。线程数下降后,如果任务仍在无界积压,性能瓶颈可能已转移到队列或下游资源。

实现细节见 Linux 内核 /proc 文档、Python asyncio Task 文档与 Effective Go 的 goroutine 章节。

目录与阅读设置

记录一个想法

为什么协程比线程轻量

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通