操作系统 / 技术文章

上下文切换到底切换了什么

上下文切换解决的是一个核心问题:当 CPU 从线程 A 转去运行线程 B 时,怎样保存 A 的执行现场并让 B 从上次停下的位置继续执行。本文面向后端、系统与嵌入式开发者,重点拆开这个“现场”到底包含什么,以及进程切换与线程切换为什么代价不同;读完后可以从寄存器、栈、地址空间和调度状态几个维度判断一次切换究竟发生了什么。

先理解“上下文”是什么

上下文不是一个单独的数据结构,而是让一个执行流能够继续运行所需的状态集合。最核心的是 CPU 架构相关的执行状态,例如程序计数器、栈指针、通用寄存器,以及状态寄存器等。

对一个正在运行的线程来说,可以把现场抽象成两部分:一部分是 CPU 当前直接使用的寄存器状态,另一部分是内核需要维护的线程调度状态。线程被暂停后,后续恢复必须让 CPU 回到与暂停时一致的执行位置和调用栈。

需要特别注意,上下文切换不是“把整个线程内存复制一遍”。线程自己的代码、堆和大多数数据仍然留在内存中,切换主要是在执行控制权和必要的处理器状态之间做交接。

CPU 真正需要保存和恢复什么

最直观的是寄存器。假设线程 A 被抢占,硬件与内核共同保留足以恢复 A 的寄存器状态,其中通常包括程序计数器、栈指针、通用寄存器和条件码等架构状态。

程序计数器决定恢复后从哪里继续执行,栈指针决定当前函数调用栈在哪里,通用寄存器则可能保存局部计算结果、参数和临时值。某些架构还存在额外的控制寄存器或浮点、SIMD 状态,它们是否需要保存取决于架构、内核实现以及线程是否使用了相关寄存器。

以 Linux x86-64 为例,从用户态陷入内核时,入口路径会保留返回用户态需要的现场。调度器真正换任务时,底层切换保存内核调用约定所需的寄存器,并切换到下一任务的内核栈。两者可以发生在一次阻塞系统调用中,也可以只有前者,例如系统调用立即完成并返回同一线程。扩展寄存器和其他体系结构状态另按具体实现管理。

栈为什么属于上下文的一部分

每个线程通常都有自己的内核栈,用户态线程还会对应自己的用户栈。线程运行过程中,函数调用、局部变量、返回地址以及异常处理相关状态都会依赖栈。

当线程 A 被切走时,并不是把整个栈复制到别处,而是保存能够定位当前栈的状态,让内核之后重新切回 A 时继续使用原来的栈。线程 B 恢复时,则切换到 B 对应的栈和寄存器组合。

这也是线程能够独立运行、却又共享同一进程地址空间的重要原因:线程通常拥有独立的执行栈与寄存器上下文,但不需要为代码和堆重新建立一份独立副本。

共享地址空间与更换地址空间差在哪里

线程切换与进程切换不能简单画等号。多个线程可以属于同一个进程,因此它们共享同一虚拟地址空间;当 CPU 从同一进程中的线程 A 切到线程 B 时,重点变化通常是寄存器、栈和调度相关状态,而地址空间本身可以保持不变。

如果两个被调度线程使用不同的用户地址空间,内核还要切换页表或相应的地址空间状态。支持地址空间标识的处理器可以区分多个地址空间的 TLB 项,减少完全失效的需要。映射改变、标记复用或安全隔离仍可能要求失效部分或全部项,实际行为取决于架构和内核配置。

因此,“一次上下文切换多少成本”不能只看是否发生了线程切换,还要看是否跨越地址空间、是否涉及额外寄存器状态,以及处理器缓存和地址转换缓存能否继续命中。

为什么切换后 CPU 还可能变慢

上下文切换本身只是开销的一部分,更重要的问题可能出现在切换之后。线程 B 获得 CPU 后,A 留在指令缓存、数据缓存和 TLB 里的内容,未必能帮助 B 访问自己的工作集。换核也可能改变 B 能利用的缓存内容。

因此可以把一次切换后的影响分成两个层次:第一层是内核保存和恢复执行现场的直接成本;第二层是新线程运行时因为缓存、分支预测或地址转换局部性变化产生的间接成本。

这也是为什么“上下文切换次数高”只能作为性能信号,不能直接等同于“性能一定差”。如果线程之间工作集相近、切换成本较低,影响可能有限;如果频繁切换伴随大量缓存失效和同步竞争,整体代价就会明显放大。

在 Linux 中观察线程切换计数

Linux 在 /proc/self/task/<TID>/status 中提供线程级的自愿和非自愿切换累计计数。下面让主线程与工作线程通过本地套接字往返,观察主线程进入阻塞等待时的计数变化。

python
from pathlib import Path
from socket import socketpair
from threading import Thread, get_native_id

rounds = 200
fields = ("voluntary_ctxt_switches", "nonvoluntary_ctxt_switches")

def switches():
    status = Path(f"/proc/self/task/{get_native_id()}/status").read_text()
    values = dict(line.split(":", 1) for line in status.splitlines() if ":" in line)
    return [int(values[field]) for field in fields]

def reply(peer):
    for _ in range(rounds):
        if peer.recv(1) != b"x":
            return
        peer.sendall(b"y")

caller, peer = socketpair()
with caller, peer:
    worker = Thread(target=reply, args=(peer,))
    worker.start()
    before = switches()
    for _ in range(rounds):
        caller.sendall(b"x")
        assert caller.recv(1) == b"y"
    worker.join()
    after = switches()

for field, earlier, later in zip(fields, before, after):
    print(field, later - earlier)

通常可以看到自愿切换增加,具体次数会随线程交错和主机负载变化。一轮收发可能无需阻塞,也可能包含额外调度。计数描述发生的次数,定位延迟还要测等待时间、运行队列与处理器事件。

如何建立正确的上下文切换心智模型

可以用一条固定链路理解上下文切换:线程 A 停止运行,内核保存恢复所需的 CPU 与调度状态,调度器选择线程 B,内核恢复 B 的状态,CPU 从 B 保存的程序位置继续执行;如果跨进程,还要处理对应的地址空间切换问题。

由此可以记住三个容易混淆的结论。第一,切换的核心不是复制线程内存,而是交接执行现场。第二,线程之间共享地址空间并不意味着共享寄存器和执行栈。第三,切换成本不仅来自保存恢复动作,还可能来自随后出现的缓存和地址转换局部性损失。

理解这些边界后,分析 CPU 使用率、调度延迟或线程抖动时,就不会把“上下文切换”误解成单纯的线程暂停与恢复,而能够继续追问到底是寄存器保存、地址空间变化、调度频率,还是切换后的微架构状态变化在消耗时间。

目录与阅读设置

记录一个想法

上下文切换到底切换了什么

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

登录哪都通