PHP 协程原理深度解析:Generator 背后藏着什么秘密?

你以为的协程 vs 真实的协程

很多同学第一次听到"协程"这个词，脑子里会冒出两个错误理解：

❌ 误区 1：协程就是多线程，能并行执行
❌ 误区 2：协程用了魔法，自动帮你处理并发

实际上：

协程是单线程的、协作式的、用户态调度的执行单元。

它的核心思想只有一句话：遇到 I/O 等待，主动让出 CPU，等 I/O 好了再回来继续跑。

第一章：从 Generator 说起

PHP 协程的基础是 Generator（生成器），它是协程的最小实现形式。先看一段代码：

<?php

/**
 * 最简单的 Generator 示例
 * yield 是暂停点，每次调用 next() 会恢复到下一个 yield
 */
functionsimpleGenerator(): Generator
{
echo"【步骤 1】开始执行\n";
yield'first';   // 第一次暂停，返回 'first'

echo"【步骤 2】恢复执行\n";
yield'second';  // 第二次暂停，返回 'second'

echo"【步骤 3】执行完毕\n";
// Generator 函数结束
}

$gen = simpleGenerator(); // 此时函数体【不会执行】，只是创建 Generator 对象

echo"Generator 已创建，函数体还没跑\n";

$gen->current(); // 运行到第一个 yield，输出"步骤 1"，暂停
echo"第一次暂停，返回值：" . $gen->current() . "\n";

$gen->next();    // 恢复，运行到第二个 yield，输出"步骤 2"，暂停
echo"第二次暂停，返回值：" . $gen->current() . "\n";

$gen->next();    // 恢复，运行完毕，输出"步骤 3"

输出结果：

Generator 已创建，函数体还没跑
【步骤 1】开始执行
第一次暂停，返回值：first
【步骤 2】恢复执行
第二次暂停，返回值：second
【步骤 3】执行完毕

这里有个关键认知：

这就是协程的本质：可以暂停和恢复的函数。

第二章：PHP 底层是怎么实现暂停/恢复的？

2.1 Generator 的内部结构

PHP 的 Generator 底层对应一个 C 结构体 _zend_generator，核心字段如下：

// PHP 源码简化版（zend_generator.h）
struct _zend_generator {
    zend_object std;

// 保存当前执行状态（寄存器、栈帧、opline 指针）
    zend_execute_data *execute_data;

// yield 返回给调用方的值
    zval value;

// 调用方 send() 传进来的值
    zval send_target;

// 执行状态标志
uint32_t flags;
// ZEND_GENERATOR_CURRENTLY_RUNNING = 正在执行
// ZEND_GENERATOR_COMPLETED        = 已完成
};

当执行到 yield 时，PHP 会：

1. 把当前函数的**执行栈帧（execute_data）**保存到堆上
2. 把 yield 的值写入 $gen->value
3. 把控制权交回给调用方

当调用 $gen->next() 时，PHP 会：

1. 从堆上恢复执行栈帧
2. 把 send() 传入的值写入 send_target
3. 从上次 yield 之后继续执行

这整个过程发生在用户态，不需要内核介入，比线程切换（需要上下文切换）轻量 100 倍以上。

2.2 yield from 与协程调度

PHP 7 引入了 yield from，让 Generator 可以委托给另一个 Generator，这是实现协程调度器的基础：

<?php

/**
 * yield from 示例：子协程委托
 */
functioninnerCoroutine(): Generator
{
echo"内层协程开始\n";
yield'inner-1';
echo"内层协程继续\n";
yield'inner-2';
return'inner-done'; // Generator 可以有返回值！
}

functionouterCoroutine(): Generator
{
echo"外层协程开始\n";
yield'outer-1';

// 委托给内层协程，内层跑完才继续
$innerResult = yieldfrominnerCoroutine();

echo"内层协程返回值：{$innerResult}\n";
yield'outer-2';
}

$gen = outerCoroutine();
while ($gen->valid()) {
echo"当前 yield 值：" . $gen->current() . "\n";
$gen->next();
}

第三章：真正的协程并发——EventLoop 登场

Generator 只是协程的暂停/恢复机制，要实现真正的"并发"，还需要 EventLoop（事件循环）。

3.1 协程 + EventLoop 的工作原理

┌─────────────────────────────────────────────────────┐
│                     EventLoop                        │
│                                                      │
│  ┌──────────┐  遇到IO   ┌──────────────────────────┐ │
│  │ 协程 A   │ ────────→ │  IO 等待队列              │ │
│  │(HTTP请求)│  yield    │  - 协程A等待 MySQL 响应   │ │
│  └──────────┘           │  - 协程B等待 Redis 响应   │ │
│                         └──────────────────────────┘ │
│  ┌──────────┐  运行中   ┌──────────────────────────┐ │
│  │ 协程 B   │           │  IO 完成，恢复协程         │ │
│  │(Redis查询)│◄─────────│  - MySQL 响应 → 恢复协程A │ │
│  └──────────┘           │  - Redis 响应 → 恢复协程B │ │
│                         └──────────────────────────┘ │
└─────────────────────────────────────────────────────┘

关键点：单线程内，当协程 A 等待 MySQL 时，EventLoop 切换去跑协程 B；B 等待 Redis 时，说不定 A 的 MySQL 响应回来了，再切回去继续 A。这就是"协程并发"。

3.2 用纯 PHP 实现一个简单调度器

<?php

/**
 * 极简协程调度器（纯教学用途）
 * 演示 EventLoop 如何调度多个协程
 */
classSimpleScheduler
{
/** @var SplQueue<Generator> 待运行的协程队列 */
privateSplQueue$queue;

publicfunction__construct()
{
$this->queue = newSplQueue();
    }

/**
     * 添加协程到调度队列
     */
publicfunctionadd(Generator$coroutine): void
{
$this->queue->enqueue($coroutine);
    }

/**
     * 运行所有协程直到全部完成
     */
publicfunctionrun(): void
{
while (!$this->queue->isEmpty()) {
/** @var Generator $coroutine */
$coroutine = $this->queue->dequeue();

// 协程还没跑完，继续推进
if ($coroutine->valid()) {
$coroutine->next();

// 还没完成，放回队尾等下次调度
if ($coroutine->valid()) {
$this->queue->enqueue($coroutine);
                }
            }
        }
    }
}

/**
 * 模拟一个需要多步骤的协程任务
 *
 * @param string $name 协程名称
 * @param int $steps 执行步骤数
 */
functiontask(string$name, int$steps): Generator
{
for ($i = 1; $i <= $steps; $i++) {
echo"[{$name}] 执行第 {$i} 步\n";
yield; // 让出 CPU，给其他协程机会
    }
echo"[{$name}] 完成!\n";
}

// 创建调度器，加入 3 个并发任务
$scheduler = newSimpleScheduler();
$scheduler->add(task('任务A', 3));
$scheduler->add(task('任务B', 2));
$scheduler->add(task('任务C', 4));

$scheduler->run();

输出（交替执行！）：

[任务A] 执行第 1 步
[任务B] 执行第 1 步
[任务C] 执行第 1 步
[任务A] 执行第 2 步
[任务B] 执行第 2 步
[任务C] 执行第 2 步
[任务A] 执行第 3 步
[任务B] 完成!
[任务C] 执行第 3 步
[任务A] 完成!
[任务C] 执行第 4 步
[任务C] 完成!

三个任务交替执行，这就是协程调度的威力。

第四章：Swoole 协程 —— PHP 协程的工业级实现

手写调度器只是玩具，生产环境用 Swoole。Swoole 在 PHP 扩展层实现了完整的协程运行时，彻底接管了 I/O 操作。

4.1 Swoole 协程的底层架构

PHP 用户代码
     ↓ 调用 Co::create() 创建协程
Swoole 协程调度器（C++ 实现）
     ↓ 遇到 I/O
Hook 层（替换 file_get_contents / mysql_connect / curl 等）
     ↓
libuv / epoll（Linux）/ kqueue（macOS）
     ↓ I/O 完成事件
调度器恢复对应协程
     ↑ 继续执行 PHP 代码

Swoole 的"协程 Hook"是杀手锏：你用原来的 PDO、Redis、curl 代码，Swoole 自动把它变成协程异步调用，不需要改业务代码！

<?php

// 开启 Hook，让原生 PHP 函数自动协程化
Swoole\Runtime::enableCoroutine(SWOOLE_HOOK_ALL);

Swoole\Coroutine\run(function () {
// 并发创建 5 个协程，同时发起 HTTP 请求
$wg = newSwoole\Coroutine\WaitGroup();

$results = [];

for ($i = 0; $i < 5; $i++) {
$wg->add();
Swoole\Coroutine::create(function () use ($i, &$results, $wg) {
            // 这里用 curl，被 Hook 后自动变成协程异步
            $ch = curl_init("https://httpbin.org/delay/1?id={$i}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 5);

$start = microtime(true);
$response = curl_exec($ch);   // ← 遇到网络等待，自动让出 CPU
$duration = round((microtime(true) - $start) * 1000);

curl_close($ch);
$results[$i] = "协程 {$i}: {$duration}ms";
$wg->done();
        });
    }

$wg->wait(); // 等待所有协程完成

foreach ($resultsas$result) {
echo$result . "\n";
    }
});

性能对比：

4.2 协程 vs 多进程 vs 多线程

<?php

/**
 * 三种并发模型对比（概念演示）
 *
 * 场景：处理 100 个 API 请求，每个耗时 100ms（I/O bound）
 */

// ❌ 同步串行
// 耗时：100 * 100ms = 10,000ms
// 内存：低，只有 1 个执行上下文

// ⚠️ 多进程（PHP-FPM 模式）
// 耗时：ceil(100/32) * 100ms ≈ 400ms（32个 worker）
// 内存：高，每进程 ~30MB，100请求需要 100 个进程=3GB 内存峰值
// 上下文切换：内核态，开销大

// ✅ Swoole 协程
// 耗时：~100ms（全部并发，只等最慢那个）
// 内存：低，每协程 ~4KB 栈，100协程 ≈ 400KB
// 上下文切换：用户态，几乎零开销

第五章：实战 —— 协程并发数据库查询

来一个真实场景：电商首页需要同时查询商品、用户信息、推荐列表、广告位四个接口。

<?php

useSwoole\Coroutine;
useSwoole\Coroutine\Channel;

/**
 * 协程并发查询演示
 * 同时发起 4 个数据库/Redis 查询，总耗时 = 最慢那个查询的时间
 */
functionfetchHomePageDataConcurrently(): array
{
$channel = newChannel(4); // 容量 4 的 Channel，用于收集结果

// 协程 1：查商品列表（模拟耗时 200ms）
Coroutine::create(function () use ($channel) {
Coroutine::sleep(0.2); // 模拟 DB 查询
$channel->push(['products' => ['iPhone 15', 'MacBook Pro', 'AirPods']]);
    });

// 协程 2：查用户信息（模拟耗时 50ms）
Coroutine::create(function () use ($channel) {
Coroutine::sleep(0.05); // 模拟 Redis 查询
$channel->push(['user' => ['id' => 1001, 'name' => '张三', 'vip' => true]]);
    });

// 协程 3：查推荐列表（模拟耗时 150ms）
Coroutine::create(function () use ($channel) {
Coroutine::sleep(0.15); // 模拟推荐算法 API
$channel->push(['recommendations' => ['商品A', '商品B', '商品C']]);
    });

// 协程 4：查广告位（模拟耗时 80ms）
Coroutine::create(function () use ($channel) {
Coroutine::sleep(0.08); // 模拟广告服务
$channel->push(['ads' => ['活动1', '促销2']]);
    });

// 等待 4 个结果全部返回
$result = [];
for ($i = 0; $i < 4; $i++) {
$data = $channel->pop(3.0); // 最多等 3 秒
if ($data !== false) {
$result = array_merge($result, $data);
        }
    }

return$result;
}

// 在 Swoole 协程上下文中运行
Coroutine\run(function () {
$start = microtime(true);

$data = fetchHomePageDataConcurrently();

$duration = round((microtime(true) - $start) * 1000);
echo"并发查询完成，耗时：{$duration}ms\n";
echo"获取数据：" . implode(', ', array_keys($data)) . "\n";

// 同步串行耗时：200 + 50 + 150 + 80 = 480ms
// 协程并发耗时：max(200, 50, 150, 80) ≈ 200ms
// 提升：约 2.4 倍
});

性能数据：

• 同步串行：200 + 50 + 150 + 80 = 480ms
• 协程并发：max(200, 50, 150, 80) ≈ 200ms
• 性能提升：2.4 倍

查询越多、I/O 越慢，协程的优势越明显。

第六章：使用协程的注意事项

⚠️ 1. 不是所有场景都适合协程

适合协程的场景：
✅ 高并发 I/O（HTTP 请求、数据库、Redis、文件读写）
✅ 需要同时等待多个外部接口返回结果

不适合协程的场景：
❌ CPU 密集型（大量计算、图像处理）— 用多进程
❌ 简单的 PHP 脚本 — 用普通 PHP 即可

⚠️ 2. 协程安全问题

<?php

// ❌ 错误示例：协程共享全局状态，数据竞争
$globalCounter = 0;

Coroutine::create(function () {
global$globalCounter;
$tmp = $globalCounter;
Coroutine::sleep(0.001); // 让出 CPU，其他协程可能修改 $globalCounter
$globalCounter = $tmp + 1; // 数据竞争！结果不可预期
});

// ✅ 正确示例：每个协程用独立变量，通过 Channel 通信
$channel = newChannel(1);
Coroutine::create(function () use ($channel) {
    $counter = 0;
$counter++;
$channel->push($counter); // 通过 Channel 传递结果
});
$result = $channel->pop();

⚠️ 3. 协程不能替代进程隔离

协程是单线程的，一个协程崩溃（PHP Fatal Error）会导致整个进程挂掉。生产环境一定要配合 Supervisor + 进程守护。

总结

用一张图总结 PHP 协程的核心知识：

PHP 协程体系
├── 基础层：Generator（yield 暂停/恢复机制）
│   ├── current() — 获取 yield 的值
│   ├── next()    — 推进到下一个 yield
│   └── send()    — 向协程传入值并推进
│
├── 调度层：EventLoop（事件循环）
│   ├── 协程队列管理
│   ├── I/O 事件监听（epoll/kqueue）
│   └── 协程切换（用户态，极低开销）
│
└── 工业级：Swoole 协程运行时
    ├── SWOOLE_HOOK_ALL — 自动 Hook 原生 PHP I/O
    ├── Coroutine::create() — 创建协程
    ├── Channel — 协程间通信
    └── WaitGroup — 等待协程组完成

PHP 协程的本质只有两句话：

1. yield
    让出 CPU，保存现场到堆上
2. EventLoop 监听 I/O，完成后恢复现场继续跑

高并发不是魔法，是让 CPU 在等待的间隙里去做别的事。