PHP 的异步编程 该怎么选择

PHP 的传统执行模型是同步的，这意味着代码按照语句出现的顺序逐条执行。这本身并非问题，因为同步思维往往更为简单。

当要求 PHP 开发者实现 SQL 分页展示时，他们通常会先执行一条统计总数的查询，再执行第二条查询获取当前页的数据。总记录数对于生成分页链接（首页、下一页、末页等）是必需的。

当 SQL 服务器处理第一条计数查询时，PHP 服务器处于等待状态，收到响应后才执行第二条查询。

当然，存在一次性获取两种信息的方法，但那不是本文的主题，请保持专注。

从这个分页示例中，我们可以看到潜在的优化空间：在 SQL 服务器处理第一条查询的同时启动第二条查询。但要注意，在拿到计数结果之前我们不会显示分页链接，因此即使计数查询先完成，也需要等待另一条查询的结果。

由此可见，异步操作的管理不仅限于并行执行任务，还包括管理响应的处理顺序。

存在许多需要异步执行代码的场景，这通常与 I/O 操作相关：HTTP 请求、数据库访问、文件读写或启动外部进程。

PHP 是异步的吗？

要判断 PHP 是否"异步"，首先需要理解"异步"的含义。异步指的是：不同时发生。当某项操作耗时时，与其等待完成，不如先去做其他事情，等操作完成后再回来继续。因此，异步的核心在于操作是非阻塞的。

人们常常混淆异步和并行。

打个比方：异步如同一位厨师将锅接满水放在灶台上开火，趁水烧开的工夫去切蔬菜。等蔬菜切好、水也烧开，就开始烹饪。

并行则是两位厨师：一位切蔬菜的同时，另一位负责烧水。蔬菜切好、水也烧开后，由第一位厨师负责烹饪。

并行节省了时间，因为切蔬菜与烧水准备是同时进行的。但两种模式下，水烧开的过程中都可以去做其他事情。

具体而言，我们的"厨师"就是机器的 CPU/GPU。

PHP 的异步能力

从 2002 年 PHP 4.3 发布起，一项重要功能被引入：Streams。通过 stream_set_blocking() 和 stream_select() 函数，PHP 进入了异步编程时代。

$h = fopen(__FILE__, 'r');
stream_set_blocking($h, false);
$content = '';
while (!feof($h)) {
   
    $read = array($h);
    $write = $except = null;
    // 检查是否有可读内容，最多等待 1000 微秒
    // 永远不要设为 0，否则会导致 CPU 过度占用
    $ready = stream_select($read, $write, $except, 1000);

    if ($ready === 0) {
   
        // 没有可读内容，稍作等待
        // 或者去做其他事情...
        usleep(1000);
        continue;
    }
    $chunk = fgets($h, 1024);
    if ($chunk !== false) {
   
        $content .= $chunk;
    }
}

fclose($h);

echo $content;

注意，这段示例代码刻意简化，未处理错误等情况。

在 usleep(1000) 的位置，可以执行其他操作，比如读取另一个文件，甚至向其他服务器发起 HTTP 请求。不过，如果你的文件系统很快，可能不会进入等待时间。这种技术更适合处理慢速文件系统或其他类型的 I/O 操作。

23 年前 PHP 就已支持异步编程，然而几年前人们还说 PHP 不是异步语言，为什么？

因为实现异步不仅仅是启动非阻塞处理，还需要有机制来管理这些等待时间。

这就引入了协程的概念。协程是一种可以被挂起、之后恢复的函数。

协程与 Fiber

2013 年 6 月，PHP 5.5 引入生成器（Generators）后，开发者开始将其改造为协程使用。

$generator = (function() {
   
    $count = 3;
    echo "开始\n";
    while(true) {
   
        yield; // 挂起函数（生成器）
        echo "有结果了吗？\n";
        $count--;
        if ($count === 0) {
   
            return; // 收到结果，停止
        }
    }
})();

$generator->current(); // 启动处理
do {
   
    echo "做其他事情\n";
    $generator->next(); // 恢复函数执行（从 yield 处继续）
} while ($generator->valid()); // 函数是否结束？
echo "结束\n";

PHP 8.1 的发布标志着 PHP 向异步编程迈出了重要一步，引入了 Fiber 作为真正的协程技术基础。

$fiber = new Fiber(function() {
   
    $count = 3;
    echo "开始\n";
    while(true) {
   
        Fiber::suspend(); // 挂起 fiber
        echo "有结果了吗？\n";
        $count--;
        if ($count === 0) {
   
            return; // 收到结果，停止
        }
    }
});

$fiber->start(); // 启动处理
do {
   
    echo "做其他事情\n";
    $fiber->resume(); // 恢复 fiber 执行
} while (!$fiber->isTerminated()); // fiber 是否结束？
echo "结束\n";

你会发现代码与使用生成器时几乎没什么变化。

虽然 PHP 从 4.3 版本就具备底层异步能力，但 PHP 8.1 引入的 Fiber 标志着一个转折点。Fiber 提供了原生且强大的异步编程工具，使其变得更加自然。

Event Loop

既然我们已经知道如何中断协程并执行非阻塞处理，接下来需要管理多个并行任务，因为单个异步处理的意义不大。

谈到并行，人们常会想到线程——线程提供进程间的自然隔离，并能利用多核 CPU，这对计算密集型任务非常有吸引力。

然而，并行、特别是多线程的实现更为复杂，调试更困难，还存在死锁和内存并发访问的风险。

正是出于这些原因，Web 领域更倾向于使用另一种模式：EventLoop。Web 场景的特点是并发连接数可能非常高。

EventLoop 是一个无限循环，它监听事件队列（如结果到达），并以串行方式逐个处理。

我们将待处理的任务加入这个队列，然后启动循环。

问题是如何告知 EventLoop 如何处理任务的结果？很简单，我们指定一个回调函数，当结果可用时 EventLoop 会调用它。

注意：下面代码中的 EventLoop 是虚构的，但代表了大多数 EventLoop 的工作方式。

$loop = EventLoop::get();
$loop->addReadStream('file.txt', function(string $data) {
   
    echo "读取到的数据：{$data}";
});
echo "启动 EventLoop\n";
$loop->run();

这段代码的预期输出：

启动 EventLoop
读取到的数据：<file.txt 的内容>

同时读取两个文件的情况：

$loop = EventLoop::get();
$loop->addReadStream('/dev/cdrom/file1.txt', function(string $data) {
   
    echo "数据 1 已读取：{$data}";
});
$loop->addReadStream('/dev/fb0/file2.txt', function(string $data) {
   
    echo "数据 2 已读取：{$data}";
});
echo "启动 EventLoop\n";
$loop->run();

根据存储介质的性能，输出可能是：

启动 EventLoop
数据 2 已读取：<软盘数据>
数据 1 已读取：<光盘数据>

Promise

当需要链式执行异步操作时，就会陷入回调地狱（或末日金字塔）：回调函数层层嵌套。

$loop = EventLoop::get();
$loop->addReadStream('file.txt', function(string $data) {
   
    EventLoop::get()->defer(function() use ($data) {
   
        return compressData($data);
    }, function ($compressedData) {
   
        EventLoop::get()->addWriteStream(
            'http://foo', 
            $compressedData, 
            function (Response $response) {
   
                echo "数据已发送\n";
            });
    });
});
echo "启动 EventLoop\n";
$loop->run();

如果再加上错误处理，代码会更加复杂难读。

为了改善可读性和更好地管理异步，Promise（承诺）的概念值得考虑。

Promise 的概念于 80 年代在 Multilisp 等语言中引入，但真正流行是在 2009 年，Dojo、Q、jQuery.Deferred 等 JavaScript 库率先实现了它。

Promise 是什么？它是一个包含处理结果（当前或未来）的对象。打个比方：

"我不会立即给你处理结果，但我承诺稍后会在这个对象里给你。"

示例代码：

$promise = new Promise(function ($resolve, $reject) {
   
    echo "启动 Promise\n";
    $resolve("Hello, world!");
});

运行这段代码会看到 "启动 Promise"，但 "Hello, world!" 在哪里？为什么要调用 $resolve()？

实际上，需要使用 then() 方法配合回调函数：

$promise = new Promise(function ($resolve, $reject) {
   
    echo "启动 Promise\n";
    $resolve("Hello, world!");
});

$promise->then(
    function ($value) {
   
        echo "Promise 结果：$value\n";
    }
);

输出：

启动 Promise
Promise 结果：Hello, world!

如果 Promise 没有被解决（resolve），什么都不会发生，只会显示启动信息。

具体来说，当 Promise 被解决时，then() 中的回调会被执行。这种情况可能发生在 Promise 内部包含协程时——协程经过长时间处理收到结果后调用 $resolve()。

配合 EventLoop 的完整示例：

$loop = EventLoop::get();

$promise = new Promise(function ($resolve, $reject) use ($loop) {
   
    echo "启动 Promise\n";
    $loop->addTimer(1, function () use ($resolve) {
   
        echo "解决 Promise\n";
        $resolve("Hello, World!");
    });
});

$promise->then(
    function ($value) {
   
        echo "结果：$value\n";
    }
);

$loop->run();

这段代码使用异步定时器在 1 秒后解决 Promise。输出：

启动 Promise
解决 Promise
结果：Hello, World!

Promise 的价值体现在哪里？回到回调地狱的问题。使用 Promise 后，代码可以这样写：

readFileAsync('file.txt')
    ->then(function ($data) {
   
        return compressDataAsync($data);
    })
    ->then(function ($compressedData) {
   
        return sendDataAsync('http://foo', $compressedData);
    })
    ->catch(function ($error) {
   
        echo "错误：{$error}\n";
    });

readFileAsync() 返回一个使用 EventLoop 的 Promise，在获得结果时解决。
compressDataAsync() 和 sendDataAsync() 同样返回 Promise。

catch() 用于处理链中任何环节的错误。现在我们不再是嵌套回调，而是回调链。

你也可以在回调中返回值，这个值会被转换为立即解决的 Promise。如果不返回任何内容，相当于返回一个值为 NULL 的已解决 Promise。

如果需要在各阶段处理错误，then() 方法接受第二个参数作为拒绝（错误）时的回调：

readFileAsync('file.txt')
    ->then(
        function ($data) {
   
            return compressDataAsync($data);
        },
        function ($error) {
   
            echo "文件读取错误：{$error}\n";
        }
    )
    ->then(function ($compressedData) {
   
        return sendDataAsync('http://foo', $compressedData);
    })
    ->catch(function ($error) {
   
        echo "错误：{$error}\n";
    });

需要注意的是，如果错误回调返回了值（或没有 return），后续的 then() 会收到一个已解决的 Promise。因此需要返回一个错误状态的 Promise 或抛出异常。

这是 then(onResolve, onReject) 中处理错误的常见陷阱之一——需要在后续所有 then() 中处理错误。上面的代码中，sendDataAsync() 会收到包含 NULL 的 $compressedData。

包选型建议

在 Packagist 上搜索 "promise" 会发现有 4 个包较为突出。

Guzzle/promises 和 php-http/promise

guzzle/promises 的下载量遥遥领先，很大程度上是因为它被流行的 HTTP 客户端 guzzle/guzzle 直接使用。

如果你已经在使用 Guzzle，可能无需选择其他包，因为它已经相当完善。

但 Guzzle/Promises 最初是为处理异步 HTTP 请求设计的，使用内部不暴露的 EventLoop，这使得集成其他类型的 I/O（如 Mysqli 异步查询或进程）更加困难。

php-http/promise 情况类似，同样专注于 HTTP 请求。

ReactPHP 和 Amp

剩下的两个重要选择是 react/promise 和 amphp/amp。

ReactPHP 提供了简单且高性能的 JavaScript Promises/A+ 标准实现（Promise 最初是 JavaScript 语言中涌现的标准，没告诉过你吧？）。

Amp 则没有完全实现 Promise：3.0 版本中没有 then()，但它实现了另一种机制——Futures，设计用于在基于生成器或 Fiber 的协程中通过 await() 等待。

因此，一边是 Promise 链式管理，另一边是面向协程的管理。

如果你用过 JavaScript 的 Promise，ReactPHP 可能更容易上手；否则 Amp 的协程方式代码可读性更好，更接近我们习惯的"同步" PHP 写法。

但无论选择 ReactPHP 还是 Amp，都需要 EventLoop。

ReactPHP 提供 react/event-loop 包，Amp 推荐使用 revolt/event-loop——这是 Amp 团队发起的项目，旨在围绕现代事件循环标准统一 PHP 异步生态。Revolt 可通过适配器与 ReactPHP 互操作。

怎么选？

如果你想使用 Promise 模式，毫无疑问应该选择 react/promise。

另一方面，Amp 提供了一种不同的写法，对某些人来说可能更"自然"，建议你两种都试试看哪个更适合。

对于 EventLoop，建议选择 Revolt，其统一生态的愿景在中期来看可能会带来回报。

还有一个参考因素：Amp v3 使用 PHP 8.1 的 Fiber，而 ReactPHP 可以在 PHP 7.1 上运行。

PHP 的异步编程 该怎么选择