3. 用户态与内核态切换：上下文切换对吞吐的影响

说到吞吐优化，很多人第一反应是调算法、改数据结构。但我得说，有时候真正拖后腿的，是那些看不见的系统开销。上下文切换就是其中之一。

说白了，每次你的程序调用系统调用——比如 read()、write()、send()——CPU 都得从用户态切到内核态。这一进一出，可不是免费的。我见过不少项目，吞吐上不去，最后定位到的问题就是上下文切换太频繁。

3.1 上下文切换到底干了什么？

每次切换，CPU 要干这几件事：

• 保存当前进程的寄存器状态（通用寄存器、PC、栈指针等）
• 加载内核态的寄存器状态
• 刷新 TLB（页表缓存）
• 执行内核代码
• 再切回来，恢复用户态寄存器

你想想看，这一套下来，几十到几百个 CPU 周期就没了。如果每秒切换几万次，那吞吐损失可不是小数目。

3.2 一个真实的例子

我记得有一次帮一个网络中间件做优化。他们的程序每秒要处理 10 万个小包，每个包都调一次 sendto()。结果呢？

我抓了个 perf stat 一看：

# perf stat -e context-switches,cpu-migrations,cycles ./my_app

 Performance counter stats for './my_app':

        12,345,678      context-switches      # 0.123 M/sec
       987,654,321      cycles                # 9.876 GHz

       1.234 secs time elapsed

每秒 12 万次上下文切换！每次切换平均消耗约 80 个周期。光切换就吃掉了一千多万个周期。这还不算缓存丢失的代价。

我当时就建议他们做批处理——把多个小包合并成一个大的 sendmmsg() 调用。结果呢？上下文切换降到每秒不到 1000 次，吞吐直接翻了 3 倍。

3.3 上下文切换的代价量化

我习惯用下面这个公式来估算切换开销：

总开销 = 切换次数 × (切换延迟 + 缓存丢失惩罚)

其中：

• 切换延迟：大约 50-200 个 CPU 周期（取决于架构）
• 缓存丢失惩罚：切换后 L1 缓存命中率可能从 95% 降到 50%，每个丢失约 10-100 个周期

举个例子：

看到了吗？差了 200 倍。这就是为什么我总说，减少上下文切换是吞吐优化的第一课。

3.4 如何测量上下文切换？

嗯，这里要注意。光靠感觉是不行的，得用工具说话。

我常用的方法：

1. perf stat：直接看 context-switches 事件
2. strace -c：统计系统调用次数和耗时
3. /proc/<pid>/status：看 voluntary_ctxt_switches 和 nonvoluntary_ctxt_switches

举个例子，用 strace -c 看你的程序：

$ strace -c ./my_app
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
 50.00    0.050000        5.00     10000           read
 30.00    0.030000        3.00     10000           write
 20.00    0.020000        2.00     10000           sendto
------ ----------- ----------- --------- --------- ----------------
100.00    0.100000                 30000           total

如果 calls 数量很大，比如每秒几万次，那上下文切换肯定是个问题。

3.5 减少上下文切换的实战技巧

这里我总结几个自己常用的方法：

• 批处理系统调用：用 readv()/writev() 代替多次 read()/write()
• 使用零拷贝技术：sendfile()、splice() 可以避免数据在用户态和内核态之间拷贝
• 异步 I/O：用 io_uring 或 epoll 减少阻塞式系统调用
• 内存映射文件：mmap() 一次映射，后续访问不需要系统调用

举个例子，用 sendfile() 代替 read() + write()：

// 传统方式：两次系统调用，两次上下文切换
char buf[4096];
read(fd_in, buf, 4096);   // 用户态 -> 内核态 -> 用户态
write(fd_out, buf, 4096); // 用户态 -> 内核态 -> 用户态

// 零拷贝方式：一次系统调用，一次上下文切换
sendfile(fd_out, fd_in, NULL, 4096); // 用户态 -> 内核态 -> 用户态

你看，从 4 次上下文切换降到 2 次。如果数据量大，效果非常明显。

3.6 知识体系图

下面这张图，是我自己画的一个上下文切换影响吞吐的逻辑图：

这张图想表达的是：每次系统调用，数据都要在用户态和内核态之间来回穿梭。穿梭的次数越多，吞吐损失越大。优化的核心思路就是——减少穿梭次数。

3.7 总结

上下文切换对吞吐的影响，说白了就是「频繁的过路费」。每次切换都要交一笔 CPU 周期和缓存命中率的税。我个人的经验是：

• 先用量化工具（perf、strace）摸清切换频率
• 然后针对性地做批处理或零拷贝优化
• 最后验证优化效果

嗯，这一节就到这里。记住一句话：减少一次上下文切换，可能比优化一百行代码更有效。