各位好，欢迎来到今天的“PHP 内核深潜”讲座。我是你们的讲师。
今天我们不聊怎么写 foreach，也不聊怎么用 Laravel 的 Eloquent 去掉那一堆该死的 .get()。我们要聊点硬核的，甚至有点“冒犯”硬件的——PHP 8.x 的 Fiber（纤程）机制。
你们知道，PHP 过去是个“老实人”。它几乎是单线程的，虽然你有 Apache/Nginx 和 PHP-FPM，但 PHP 脚本本身是同步执行的。如果你要干点 IO 密集型的工作，比如发十个 HTTP 请求，你就得等第一个结束，等第二个结束……直到第十个。这就像是你去食堂打饭，你得排完这一队再排下一队，中间不能干别的。
PHP 8 出来后，引入了 Fiber。这就像是突然给了你一个“瞬间移动”的能力。你可以说：“老板，先把这碗面端上来（开始执行），我去跟隔壁桌聊五毛钱的（挂起），聊完了我再回来接着吃（恢复）。”
但是，这背后到底发生了什么？PHP 是怎么在同一个 PHP-FPM 进程里，把代码切成无数个切片，像切蛋糕一样在内存里换来换去的？
这就要提到一个极其敏感的器官——栈。而且不是 PHP 的栈，是C 栈。
今天，我们就来扒开 PHP 8 的裤衩子，看看那个名叫 fiber_swap_context 的“魔术师”是如何在 C 栈和 PHP 栈之间跳探戈的。
一、 场景构建：当 PHP 变成了“多线程”
首先，我们要理解一个前提：Fiber 不是线程。
这是个巨大的概念误区。线程是操作系统级别的调度单位，它拥有独立的栈（C 栈）、独立的寄存器状态，甚至独立的内核描述符。而 Fiber 是“用户态线程”。它就像是在一个大宿舍里，宿舍长（PHP 线程）允许里面的某一个房客（Fiber）出门去厕所（IO 操作），然后让另一个房客进屋坐会儿。
关键在于：他们住在同一个房间里，共用同一个 C 栈。
想象一下，你的 C 栈就像是一个厨房。PHP 的执行上下文就像是厨房里的厨师。Fiber 切换，不是换个厨师，而是让厨师换了个马甲，或者让厨师停下来擦擦汗，去后面沙发上躺会儿，然后让另一个厨师接手继续炒菜。
但是，注意了，这个 C 栈的空间是有限的！通常在 Linux 上是 8MB。如果你的“厨师”在 C 栈里递归调用了几百次函数，堆栈溢出了，整个 PHP 进程就会直接爆炸。这是 Fiber 和 Go 语言协程最大的区别：Go 的协程是从堆上分配内存的，而 PHP 的 Fiber 是复用 C 栈的。
二、 核心结构体：zend_fiber_context 的秘密
要理解切换，我们得先看看 PHP 保存状态的数据结构。在 PHP 8 的源码中，这货叫 zend_fiber_context。
这其实就是一个超级大的结构体，它把 CPU 里的所有通用寄存器都给“拷贝”了一遍。为什么？因为 CPU 执行程序时，靠的就是这些寄存器记路。
在 x86-64 架构下，zend_fiber_context 大概长这样（为了方便理解，我简化了命名，但保留了关键成员）：
typedef struct _zend_fiber_context {
// 保存 RAX 寄存器：通常用来存函数的返回值或累加器
zend_long rax;
// 保存 RBX 寄存器：通常用来存静态数据或指针
zend_long rbx;
// 保存 RCX 寄存器：系统调用或循环计数
zend_long rcx;
zend_long rdx;
// 保存 RSI 和 RDI：函数调用时的第一个和第二个参数
zend_long rsi;
zend_long rdi;
// 保存 RBP 和 RSP：这俩最重要！
// RBP 是栈帧基址指针，RSP 是栈指针
zend_long rbp;
zend_long rsp;
// 保存 RIP：这叫指令指针！也就是“程序要执行到哪一行代码了”
zend_long rip;
// 还有一大堆 R8-R15，用来保存更多的临时数据
zend_long r8;
zend_long r9;
zend_long r10;
zend_long r11;
zend_long r12;
zend_long r13;
zend_long r14;
zend_long r15;
} zend_fiber_context;你可以看到，这个结构体其实就是一个巨大的“冰箱”。当 Fiber 切换时，内核会把当前的“冰箱”填满；当 Fiber 切换回来时，再把“冰箱”里的东西拿出来。
三、 切换时刻：fiber_swap_context 的 Assembly 魔法
当 PHP 执行到 Fiber::yield() 或者 Fiber::resume() 时，真正干活的是谁？不是 PHP 脚本本身，而是 PHP 内核里的 C 函数。
源码里有一个核心函数叫 fiber_swap_context（或类似的 zend_fiber_swap_context）。它基本上是在用汇编指令进行“抢劫”。
想象一下，你要把当前 Fiber 的状态存下来，并加载另一个 Fiber 的状态。
第一步：保存当前上下文
汇编层面，这通常是像这样的操作（伪代码风格）：
; 假设 fiber 是当前 Fiber 对象
; fiber->ctx 指向那个巨大的结构体
; 1. 把栈指针 RSP 存到结构体里
mov [fiber->ctx.rsp], rsp
; 2. 把栈帧基址 RBP 存到结构体里
mov [fiber->ctx.rbp], rbp
; 3. 把返回地址 RIP 存到结构体里
; 这一步很关键，因为这是函数返回后要跳回去的地方
mov [fiber->ctx.rip], rip
; 4. 把通用寄存器都搬空存进去（为了防止被覆盖）
mov [fiber->ctx.rax], rax
mov [fiber->ctx.rbx], rbx
; ... 省略 R8-R15 ...做完这些，当前 Fiber 就“晕”过去了。它的执行流被冻结在 fiber_swap_context 这一行指令。
第二步：恢复目标上下文
接下来，内核要去找另一个 Fiber，把它刚才存好的数据读出来，填进 CPU 寄存器里，让 CPU 去执行那个 Fiber 的代码。
; 指向目标 Fiber 的上下文
mov rdi, [target_fiber->ctx.rsp]
; 1. 把目标 Fiber 的栈指针读出来，这就是新的栈顶
mov rsp, rdi
; 2. 把目标 Fiber 的栈帧基址读出来
mov rbp, [target_fiber->ctx.rbp]
; 3. 把目标 Fiber 的指令指针读出来，CPU 会跳到那里继续跑
mov rip, [target_fiber->ctx.rip]
; 4. 把所有通用寄存器读回来
mov rax, [target_fiber->ctx.rax]
mov rbx, [target_fiber->ctx.rbx]
; ... 省略 R8-R15 ...执行完这一连串 mov 之后，CPU 惊奇地发现：咦？我的栈指针变了，我的代码计数器变了，我的寄存器里的值也变了。但我还能接着跑！
于是，CPU 继续执行 fiber_swap_context 下一条指令，仿佛什么都没发生过。
四、 PHP 栈的“幽灵”与 C 栈的“实体”
好，现在我们来看看C 栈和PHP 栈的区别。
C 栈：地基
C 栈是 PHP 进程的基础设施。它负责：
- 存放函数调用的返回地址（RIP）。
- 存放局部变量（虽然 PHP 不像 C 那样直接在栈上开变量，但内部调用 C API 时会用到）。
- 调用
zend_execute执行 PHP 字节码。
PHP 栈：装饰
PHP 栈是 PHP 引擎特有的。它主要管理：
- 当前函数的局部变量。
- 调用栈帧（Call Frame）。
- 对象属性、引用计数等。
Fiber 切换的精妙之处在于：它只切换 C 栈指针（RSP）和 RIP，从而间接实现了 PHP 栈的切换。
当你调用 Fiber::resume() 时，PHP 引擎会恢复目标 Fiber 的 C 栈。但是，PHP 栈本身呢？
PHP 的栈是动态的。通常情况下，PHP 执行代码时，是从 PHP 栈的底部向顶部生长的。当 Fiber 切换时，PHP 引擎会做一件事：保存当前的 PHP 执行上下文（包括当前调用的函数、变量、OPcache 状态）到 Fiber 对象中。
这就好比：你把厨房里的菜刀、锅铲都收进抽屉了，然后换了双筷子，继续炒菜。对 PHP 来说，Fiber 就像是“换了一双筷子”，但“厨房的灶台”（C 栈）还是那个灶台。
五、 代码演示：用 Debug 看见切换
光说不练假把式。我们写一段代码，看看 Fiber 在内存里到底是怎么折腾的。
<?php
$fiber = new Fiber(function () {
echo "1. Fiber 开始执行n";
// 切换到外部
Fiber::suspend();
echo "2. Fiber 被恢复了！n";
});
echo "0. 主线程开始n";
// 启动 Fiber
$fiber->start();
echo "3. 主线程继续运行n";
// 恢复 Fiber
$fiber->resume();
echo "4. 主线程结束n";预期输出：
0. 主线程开始
1. Fiber 开始执行
3. 主线程继续运行
2. Fiber 被恢复了！
4. 主线程结束底层发生了什么？
- Start: 调用
$fiber->start()。这本质上是一个Fiber::resume()，但目标 Fiber 还没准备好（或者叫“运行态”）。内核会调用fiber_swap_context，把主线程的上下文存到 Fiber 对象里，然后把 Fiber 的上下文恢复到 CPU 上。CPU 开始执行 Fiber 的代码。 - Yield: 执行到
Fiber::suspend()。这一步是fiber_swap_context的重载版本。它再次交换上下文，把 Fiber 的上下文存回 Fiber 对象，把主线程的上下文恢复回来。此时 Fiber 处于“挂起”状态。 - Resume: 主线程调用
$fiber->resume()。内核再次交换上下文。这次是拿 Fiber 对象里存好的数据，恢复给 CPU。CPU 跳回 Fiber 刚才暂停的地方，继续执行。
六、 深坑：为什么 Fiber 容易导致堆栈溢出？
这是 Fiber 最大的“坑”，也是理解 C 栈机制的关键。
如果你在 Fiber 内部递归调用 PHP 函数，会发生什么？
$fiber = new Fiber(function () {
// 这里的递归深度控制不好，就会炸
recursive_function(0);
});
function recursive_function($n) {
if ($n > 1000) return;
recursive_function($n + 1);
}
$fiber->start();悲剧发生了。
PHP 里的递归，最终会调用大量的 C 函数（比如 zend_eval_string、execute_ex 等）。这些 C 函数调用会消耗C 栈。
因为 Fiber 是复用 C 栈的，如果你在一个 Fiber 里递归太深，你的 PHP 栈（虚拟的）可能才用了一半，但你的 C 栈（物理的）已经满了。CPU 的堆栈指针 rsp 已经指向了 8MB 之外的内存区域。
结果： Segmentation Fault。进程崩溃。没有任何 PHP 错误提示，只有服务器日志里的一行 Fatal error: Allowed memory size exhausted（虽然内存没溢出，但栈溢出了）。
对比 Go 语言：
Go 的协程一开始就从堆上申请一大块内存做栈。想递归多少层都可以，直到你手动调整大小。PHP 的 Fiber 就像是在挤牙膏，空间有限，且不能动态扩展（至少在 PHP 8.1 之前是不行的）。
解决方案：
- 控制递归深度。 这是唯一的办法。
- 使用迭代代替递归。 在 Fiber 里写
while循环，别写递归。 - 限制 Fiber 数量。 别搞几万个 Fiber 同时挂着，每个 Fiber 都占着 8MB 的 C 栈（虽然只用了几 KB，但那块内存是锁定的）。
七、 性能分析：CPU 的“感冒”
Context Switch（上下文切换）是非常昂贵的操作。
想象一下 CPU 是个忙碌的老板。
- 无 Fiber（同步）： 老板一直盯着 A 桌干活，效率最高。
- 有 Fiber（异步）： 老板（PHP 线程）盯着 A 桌干活 -> 发现没菜了 -> 保存老板状态（把文件摊开，记录进度） -> 切换到 B 桌 -> 做菜 -> 切回 A 桌 -> 恢复老板状态（把文件盖回去，检查进度）。
这个“保存”和“恢复”的过程，就是 fiber_swap_context。
在 PHP 8 中，Fiber 的实现非常激进。它不仅保存了寄存器，还保存了大量的 PHP 运行时状态。这意味着每次 Fiber 切换，CPU 缓存（L1/L2）都会被洗刷一遍。
如果你写了类似这样的代码：
$fiber1 = new Fiber(function() { while(true) Fiber::suspend(); });
$fiber2 = new Fiber(function() { while(true) Fiber::suspend(); });
while(true) {
$fiber1->resume();
$fiber2->resume();
}你的 CPU 会非常痛苦。因为它每 10 毫秒就要在这些寄存器之间搬砖。这就是为什么 Fiber 虽然好用，但如果不加节制地滥用，反而会导致 CPU 利用率下降的原因。
八、 总结：Fiber 是个什么玩意儿？
好了，让我们把镜头拉远。
PHP 8 的 Fiber 本质上是一个轻量级的上下文切换机制。
它通过操作 C 栈（通过修改 RSP 和 RIP）来控制 CPU 的执行流，同时通过 PHP 内核 来保存和恢复 PHP 栈（变量、对象状态）。
它把“异步编程”的痛苦从写代码的层面（Callback hell, Promise chains）转移到了内存管理的层面（Stack size limits, Context switching cost）。
它就像是在 PHP 的单线程监狱里，给你装了个后门。你可以通过这个后门，在监狱里走来走去，甚至在院子里休息，但只要大门（PHP-FPM）一关，监狱（进程）崩了，谁都跑不掉。
所以，下次当你使用 Fiber 的时候，请记住那个 zend_fiber_context 结构体，记住那个 8MB 的 C 栈限制，记住 CPU 缓存的疲惫。只有理解了底层的物理限制，你才能写出既优雅又健壮的高性能 PHP 代码。
代码如人生，切不可贪多求快，否则，堆栈一满，就是一场不可挽回的崩溃。