PHP 中的异步编程

Tinywan

发布于 2026-07-01 16:21:40

880

文章被收录于专栏：开源技术小栈开源技术小栈

PHP 中的异步编程

PHP 传统的执行模型是同步的，这意味着每条指令都按照它在代码中出现的顺序依次执行。这本身并不是问题，因为同步思考通常更简单。

当你让 PHP 开发者实现一个带分页的 SQL 查询展示时，他们会先执行一条 SQL 查询来统计结果总数，然后再执行第二条查询来获取当前页的数据。结果总数用于生成分页链接：首页、下一页、最后一页等。

在 SQL 服务器处理第一条计数查询期间，PHP 服务器会等待，收到响应后才会处理第二条查询。

是的，有办法用一条查询同时获取两个结果，但这不是本文的重点，请保持专注。

在这个分页例子中，我们可以看到一个优化的机会：可以在 SQL 服务器处理第一条查询的同时，就开始准备第二条查询。但要注意，我们必须先显示数据，才能显示分页链接；因此即使计数查询已经完成，我们仍然必须先等待另一条查询的结果。

因此，管理异步操作不仅涉及处理并行任务，还需要控制响应处理的顺序。

有很多场景需要异步执行代码，最常见的是输入/输出（I/O） 操作，例如 HTTP 请求、数据库查询、文件访问或启动外部进程。

PHP 是异步的吗？

要判断 PHP 是否“异步”，我们首先需要理解“异步”到底是什么意思。

“异步”的意思是：不在同一时间发生。当一个操作需要花费时间时，我们不会傻傻地等待它完成，而是去做其他事情，等操作完成后再恢复继续执行。因此，异步的核心在于操作是非阻塞的（non-blocking）。

我们常常会把异步和并行搞混。

为了说明这一点，可以把异步想象成一个厨师：他往锅里加水，放到炉子上点火。在水加热的过程中，他去切蔬菜。水烧开、蔬菜切好后，再开始正式烹饪。

如果是并行，则想象有两个厨师：一个人在切蔬菜的同时，另一个人在烧水。当蔬菜切好、水也烧开时，第一个人接手开始实际烹饪。

通过这种并行，我们节省了时间，因为在第一个人往锅里加水和点火的同时，第二个人已经开始切菜了。不过在两种情况下，水在烧开的时候，我们都在做其他事情。

具体来说，这些“厨师”就是机器的 CPU/GPU。

现在来看 PHP 的能力：从 2002 年 PHP 4.3 发布开始，就引入了一项重要特性 —— Streams[1]。

特别是 stream_set_blocking() 和 stream_select() 这两个函数，让 PHP 进入了异步编程的时代。

1 <?php
2 $h = fopen(__FILE__, 'r');
3 stream_set_blocking($h, false);
4 $content = '';
5 while (!feof($h)) {
6     $read = array($h);
7     $write = $except = null;
8     // 检查是否有数据可读，最多等待 1000 µs
9    // 永远不要用 0，否则会大量消耗 CPU
10  $ready = stream_select($read, $write, $except, 0, 1000);
11
12  if ($ready === 0) {
13      // 没有数据可读，我们稍等一下
14        // 或者做其他事情...
15        usleep(1000);
16       continue;
17   }
18     $chunk = fgets($h, 1024);
19     if ($chunk !== false) {
20         $content .= $chunk;
21    }
22 }
23 
24 fclose($h);
25
26 echo $content;

注意：这段代码是为了说明而故意简化的，没有处理错误等情况。

我们可以用其他操作代替 usleep(1000)，比如读取另一个文件或向其他服务器发起 HTTP 请求。不过，如果你的文件系统很快，可能几乎感觉不到明显的等待时间。要观察有意义的延迟，通常需要处理较慢的文件系统或其他有延迟的 I/O 操作。

从技术上讲，PHP 支持异步编程已经 23 年 了。然而直到不久前，人们还普遍认为 PHP 不是一门异步语言。为什么？

因为支持异步不仅仅是能发起非阻塞操作，还需要提供有效的机制来管理等待时间。

这时候就轮到 协程（coroutines）[2] 登场了。协程是一种特殊的函数，它可以在某些点暂停执行，稍后恢复，并保留中间的状态。

2013 年 6 月，随着 PHP 5.5 引入生成器（generators）[3]，开发者开始将其用作协程的替代方案。

1 <?php
2 $generator = (function() {
3     $count = 3;
4     echo "Start\n";
5     while(true) {
6         yield; // 暂停函数（生成器）
7        echo "Are there results?\n";
8        $count--;
9         if ($count === 0) {
10             ; // 收到结果，停止
11        }
12     }
13 })();
14
15 $generator->current(); // 开始处理
16 do {
17     echo "Do something else\n";
18     $generator->(); // 恢复函数（从 yield 处继续）
19 } while ($generator->valid()); // 函数是否结束？
20 echo "End\n";

可在 3v4l.org 上测试这段代码

直到 PHP 8.1 版本，PHP 才真正迈向异步编程，引入了 Fibers[4]，为真正的协程提供了技术基础。

 echo "End\n";

<?php
$fiber = new Fiber(function() {
    $count = 3;
    echo "Start\n";
    while(true) {
        Fiber::suspend(); // 暂停 fiber
        echo "Are there results?\n";
        $count--;
        if ($count === 0) {
            ; // 收到结果，停止
        }
    }
});

$fiber->start(); // 开始处理
do {
    echo "Do something else\n";
    $fiber->resume(); // 恢复 fiber
} while (!$fiber->isTerminated()); // fiber 是否终止？
echo "End\n";

可在 3v4l.org 上测试这段代码

你会发现，和基于生成器的版本相比，代码变化非常小。

虽然 PHP 从 4.3 版本起就具备了底层的异步能力，但 PHP 8.1 的 Fibers 才是决定性的一步。它提供了强大且符合人体工程学的原生工具，让异步编程变得自然得多。

事件循环

现在我们已经知道如何中断协程并进行非阻塞处理，接下来需要管理多个并行任务，因为单个异步操作其实并没有太大用处。

当谈到并行时，人们常常会想到线程（threads），线程提供了进程之间的天然隔离，并且可以利用多个 CPU 核心，这对于计算密集型任务非常有吸引力。

然而，并行（尤其是多线程）实现起来更加复杂，调试难度更高，还会引入死锁、并发内存访问等问题。

正因如此，在 Web 领域（同时连接数可能非常高），另一种模式被广泛采用，那就是 事件循环（EventLoop）。

事件循环是一个无限循环，它持续监控一个事件队列（例如结果到达等），并按顺序、一次一个地处理它们。

因此，我们会把需要执行的任务加入这个队列，然后启动循环。

但我们如何告诉它，当操作结果到来时该做什么呢？其实非常简单：我们只需提供一个回调函数，当结果可用时，它就会调用这个函数。

注意：下面代码中展示的事件循环是虚构的，但它准确地反映了大多数事件循环的工作方式。

1<?php
2 $loop = EventLoop::get();
3 $loop->addReadStream('file.txt', function(string $data) {
4    echo "Data read: {$data}";
5 });
6 echo "Starting EventLoop\n";
7 $loop->run();

这段代码应该显示以下结果：

1 Starting EventLoop
2 Data read: <some data from file.txt>

如果同时读取 2 个文件，代码可能是这样的：


<?php
$loop = EventLoop::get();
$loop->addReadStream('/dev/cdrom/file1.txt', function(string $data) {
    echo "Data 1 read: {$data}";
});
$loop->addReadStream('/dev/fb0/file2.txt', function(string $data) {
    echo "Data 2 read: {$data}";
});
echo "Starting EventLoop\n";
$loop->run();

根据读取介质的性能不同，显示结果可能如下：

1 Starting EventLoop
2 Data 2 read: <some data from floppy>
3 Data 1 read: <some data from CDRom>

现在，如果我们需要把多个异步操作串联起来，就会陷入回调地狱（或称厄运金字塔）：回调函数层层嵌套。

<?php
$loop = EventLoop::get();
$loop->addReadStream('file.txt', function(string $data) {
    EventLoop::get()->defer(function() use ($data) {
         compressData($data);
    },function ($compressedData) {
        EventLoop::get()->addWriteStream(
            'http://foo', 
            $compressedData,
            function (Response $response) {
                echo "Data sent\n";
            });
    });
});
echo "Starting EventLoop\n";
$loop->run();

如果再加上错误处理，代码会变得更加复杂且难以阅读：

<?php
$loop = EventLoop::get();
$loop->addReadStream('file.txt', function(string $data) {
    EventLoop::get()->defer(function() use ($data) {
         compressData($data);
    },function ($compressedData) {
        EventLoop::get()->addWriteStream(
            'http://foo',
            $compressedData,
            function (Response $response) {
                echo "Data sent\n";
            },function ($error) {
                echo "Error sending data: {$error}";
            });
    },function ($error) {
        echo "Compression error: {$error}";
    });
},function ($error) {
    echo "Error reading file: {$error}";
});
echo "Starting EventLoop\n";
$loop->run();

Promises

为了让代码更易读并更好地管理异步操作，使用 Promises 是一个非常好的选择。

这个概念早在 1980 年代就出现在 Multilisp 等语言中，但真正流行是在 2009 年，JavaScript 中的 Dojo、Q、jQuery.Deferred 等库开始实现它。

什么是 Promise？它是一个对象，包含一个处理的结果 —— 这个结果可能是当前的，也可能是未来的。就像有人告诉你：

“我不会立即把处理结果给你，但我承诺稍后会把结果放到这个对象里给你。”

下面是一个例子：

<?php
$promise = new Promise(function ($resolve, $reject) {
    echo "Starting promise\n";
    $resolve("Hello, world!");
});

运行这段代码后，会看到输出 “Starting promise”，但 “Hello, world!” 在哪里？为什么要调用 $resolve()？

实际上，我们需要使用 then() 方法，并传入一个回调函数：

<?php
$promise = new Promise(function ($resolve, $reject) {
    echo "Starting promise\n";
    $resolve("Hello, world!");
});
 
$promise->then(
    function ($value) {
        echo "Promise result: $value\n";
    }
);

输出结果为：

1 Starting promise
2 Promise result: Hello, world!

如果我们没有 resolve 这个 promise，什么都不会发生，只会显示开始消息：

<?php
$promise = new Promise(function ($resolve, $reject) {
    echo "Starting promise\n";
});
 
$promise->then(
    function ($value) {
        echo "Promise result: $value\n";
    }
);

具体来说，当 promise 被 resolve 时，then() 中的回调函数就会执行。例如，promise 内部可能包含一个协程，经过长时间处理后得到结果并调用 $resolve()。

为此，我们可以结合 EventLoop，代码如下：

<?php
$loop = EventLoop::get();

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

$promise->then(
    function ($value) {
        echo "Result: $value\n";
    }
);

$loop->run();

这段代码使用了一个异步定时器，让 promise 在 1 秒后被 resolve。输出结果为：

Starting promise
Resolving promise
Result: Hello, World!

这时你可能会想：Promise 的意义到底是什么？我们回到之前的回调地狱。

使用 Promise 后，代码可以写成这样：

<?php
readFileAsync('file.txt')
    ->then(function ($data) {
         compressDataAsync($data);
    })
    ->then(function ($compressedData) {
         sendDataAsync('http://foo', $compressedData);
    })
    ->catch(function ($error) {
        echo "Error: {$error}\n";
    });

其中 readFileAsync() 函数返回一个 Promise，它会利用 EventLoop 在拿到结果时 resolve。compressDataAsync() 和 sendDataAsync() 同样返回 Promise。catch() 则用于处理整个链路中抛出的错误。是的，现在我们不再有层层嵌套的回调，而是一条链式的回调。

你还可以在回调中返回一个值，这种情况下，该值会被自动转换为一个立即 resolve 的 Promise。如果什么都不返回，则会是一个 resolve 为 NULL 的 Promise。

最后，如果需要在不同阶段处理错误，then() 方法可以接受第二个参数，用于处理 rejection（错误）情况：

<?php
readFileAsync('file.txt')
    ->then(
        function ($data) {
             compressDataAsync($data);
        },
        function ($error) {
            echo "Error reading file: {$error}\n";
        }
    )
    ->then(function ($compressedData) {
         sendDataAsync('http://foo', $compressedData);
    })
    ->catch(function ($error) {
        echo "Error: {$error}\n";
    });

不过要注意，如果错误回调返回了一个值（或者没有显式抛出异常），后续的 then() 会收到一个已 resolve 的 Promise。

因此，你必须返回一个出错的 Promise 或者 throw 一个异常。

这也是使用 then(onResolve, onReject) 处理错误时常见的陷阱之一：你必须在后续的 then() 调用中处理所有错误。在上面的代码中，sendDataAsync() 会收到包含 NULL 的 $compressedData。

该选择哪个包？

如果你在 Packagist 上搜索 “promise[5]”，你会发现有 4 个包比较突出。

Guzzle/promises 和 php-http/promise

guzzle/promises[6] 的下载量远远领先于其他包，这主要是因为它被非常流行的 HTTP 客户端 Guzzle/Guzzle[7] 直接使用。

如果你已经在使用 Guzzle，那么可能没有必要再选择其他包，因为它已经相当完整。

问题是 Guzzle/Promises 最初是为处理异步 HTTP 请求而设计的，为此它使用了一个内部的 EventLoop，并且没有将其暴露出来。这使得它很难与其他类型的输入/输出操作集成，例如异步 Mysqli 查询[8]或进程[9]。

php-http/promise[10] 包也差不多，它同样是专门用于 HTTP 请求的。

ReactPHP 和 Amp

剩下的两个重要候选者是：react/promise[11] 和 amphp/amp[12]。

ReactPHP 提供了一个简单且高性能的 JavaScript Promises/A+ 标准[13] 实现（没错，Promise 最初是在 JavaScript 语言中兴起的标准，我们之前没提过吗？）。

而 Amp 在 3.0 版本中并不完全实现传统的 Promise（没有 then() 方法）。它实现了另一种机制叫做 Futures，可以在使用生成器或 Fiber 实现的协程中通过 await() 来等待。

因此，一边是使用Promise 链的管理方式，另一边则是以协程为核心的管理方式。

如果你之前已经在 JavaScript 中使用过 Promise，那么使用 ReactPHP 可能会更简单；否则，Amp 的协程管理方式能让代码阅读起来更简单，也更接近我们平时“同步”的 PHP 写法。

不过，无论选择 ReactPHP 还是 Amp，你都需要一个 EventLoop。

ReactPHP 提供了 react/event-loop[14] 包，而 Amp 则推荐使用 revolt/event-loop[15]。Revolt 是由 Amp 团队发起的，旨在围绕一个现代标准的事件循环来统一 PHP 的异步生态。

Revolt 通过适配器可以与 ReactPHP 互操作。

那我到底该选哪个？

如果你想使用 “Promise” 模式，那没有悬念，应该选择 React/Promise。

但另一方面，Amp 提供了另一种写法，对某些人来说可能感觉更“自然”。我建议你两个都试一试，看看哪个更适合你。

不过，对于 EventLoop，我推荐你倾向于使用 Revolt，它的统一愿景在中长期可能会带来很大好处。

最后，还有一个因素可以帮助你做决定：Amp v3 使用了 PHP 8.1 的 Fiber，而 ReactPHP 并没有，它可以完美运行在较旧的 PHP 7.1 上。

引用链接

[1] Streams: https://www.php.net/manual/en/book.stream.php [2] 协程（coroutines）: https://en.wikipedia.org/wiki/Coroutine [3] 生成器（generators）: https://www.php.net/releases/5_5_0.php [4] Fibers: https://wiki.php.net/rfc/fibers [5] promise: https://packagist.org/?query=promise [6] guzzle/promises: https://github.com/guzzle/promises [7] Guzzle/Guzzle: https://github.com/guzzle/guzzle [8] 异步 Mysqli 查询: https://www.php.net/manual/en/mysqli.reap-async-query.php [9] 进程: https://www.php.net/manual/en/function.proc-open.php [10] php-http/promise: https://github.com/php-http/promise [11] react/promise: https://github.com/reactphp/promise [12] amphp/amp: https://github.com/amphp/amp [13] JavaScript Promises/A+ 标准: https://promisesaplus.com/ [14] react/event-loop: https://github.com/reactphp/event-loop [15] revolt/event-loop: https://github.com/revoltphp/event-loop