告别漫长等待：如何使用Composer和GuzzlePromises加速PHP并发请求！-composer-PHP中文网

告别漫长等待：如何使用Composer和GuzzlePromises加速PHP并发请求！

PHPz

发布： 2025-07-12 13:06:13

原创

412人浏览过

最近在开发一个处理用户提交数据的程序时，遇到了一个棘手的问题：用户输入的文本中包含各种非ASCII字符，例如中文、日文、特殊符号等等。这些字符导致程序在处理字符串时效率低下，甚至出现错误。为了解决这个问题，我尝试了多种方法，最终找到了voku/portable-ascii这个库。 Composer在线学习地址：学习地址

漫长等待的痛苦：传统PHP请求的瓶颈

想象一下，你的php应用需要从三个不同的微服务或第三方api获取数据，然后将它们整合展示给用户。最直观的做法可能是这样：

// 伪代码，模拟耗时操作
function fetchDataFromApi(string $apiName): string
{
    echo "开始从 {$apiName} 获取数据...\n";
    sleep(rand(1, 3)); // 模拟网络延迟
    echo "从 {$apiName} 获取数据完成。\n";
    return "{$apiName} 的数据";
}

$data1 = fetchDataFromApi('API A');
$data2 = fetchDataFromApi('API B');
$data3 = fetchDataFromApi('API C');

echo "所有数据获取完毕：{$data1}, {$data2}, {$data3}\n";

登录后复制

这段代码会先等待 API A 的数据返回，然后才去请求 API B，最后才是 API C。如果每个API都需要2秒，那么总共就需要至少6秒！在Web应用中，这几乎是不可接受的响应时间。在命令行脚本中，也意味着漫长的等待。这种串行阻塞的执行方式，是PHP处理I/O密集型任务时的主要瓶颈。我们渴望一种能够“同时”发起请求，并在所有请求完成后再处理结果的方式。

救星登场：Composer与Guzzle Promises

如何才能让这些请求“同时”进行呢？在PHP中，我们通常会借助“Promise”（承诺）的概念来实现非阻塞的异步操作。而 guzzlehttp/promises 库正是PHP世界中一个强大且成熟的Promise实现。

Promise是什么？ 简单来说，Promise是一个表示异步操作最终完成（或失败）及其结果值的对象。它不会立即返回结果，而是承诺在未来某个时刻提供结果。你可以为这个“承诺”注册回调函数，当操作成功时执行一个函数（onFulfilled），失败时执行另一个函数（onRejected）。

Composer如何帮助我们？ Composer是PHP的依赖管理工具，它让安装和管理像 guzzlehttp/promises 这样的库变得异常简单。你不再需要手动下载文件、配置路径，Composer会替你处理这一切。

要安装 guzzlehttp/promises，你只需要在项目根目录运行一行简单的命令：

composer require guzzlehttp/promises

登录后复制

Composer会自动下载库文件及其所有依赖，并生成自动加载文件，让你能够直接在代码中使用它。

立即学习“PHP免费学习笔记（深入）”；

实践出真知：使用Guzzle Promises实现并发

现在，让我们看看如何使用 guzzlehttp/promises 来改造上面的例子，实现非阻塞的并发请求。

<?php

require 'vendor/autoload.php'; // Composer 的自动加载文件

use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\Utils; // 用于 Promise::all()

echo "开始并发请求...\n";
$startTime = microtime(true);

// 创建一个模拟异步操作的函数，它返回一个Promise
function createAsyncFetchPromise(string $apiName): Promise
{
    return new Promise(function ($resolve, $reject) use ($apiName) {
        // 在实际应用中，这里会是真正的异步I/O操作，例如GuzzleHttp\Client::getAsync()
        // 为了演示，我们用一个简单的延迟来模拟
        $delay = rand(1, 3);
        echo " [{$apiName}] 计划延迟 {$delay} 秒...\n";
        // 在实际的异步I/O中，当操作完成时，你会调用 $resolve 或 $reject
        // 这里我们模拟一个异步任务，并在延迟后resolve
        // 注意：Promise本身是同步创建的，但它所代表的“工作”是异步的
        // 在真正的异步环境中（如ReactPHP），你不会在这里直接sleep，而是注册一个事件回调
        // 对于纯粹的同步脚本，wait()会驱动Promise的完成

        // 模拟异步完成
        \GuzzleHttp\Promise\Utils::queue()->add(function() use ($resolve, $apiName, $delay) {
            sleep($delay); // 仍然是阻塞的，但展示了Promise的结构
            echo " [{$apiName}] 完成获取数据。\n";
            $resolve("{$apiName} 的数据");
        });
    });
}

// 创建三个Promise，它们代表三个独立的异步操作
$promiseA = createAsyncFetchPromise('API A');
$promiseB = createAsyncFetchPromise('API B');
$promiseC = createAsyncFetchPromise('API C');

// 使用 Utils::all() 来等待所有Promise完成
// Utils::all() 返回一个新的Promise，当其内部所有Promise都完成时，它才完成
$allPromises = Utils::all([
    'api_a_result' => $promiseA,
    'api_b_result' => $promiseB,
    'api_c_result' => $promiseC,
]);

// 同步等待所有Promise完成并获取结果
// wait() 方法会阻塞当前进程，直到Promise被解决或拒绝
$results = $allPromises->wait();

$endTime = microtime(true);
$duration = round($endTime - $startTime, 2);

echo "\n所有数据获取完毕！\n";
echo "API A 结果: " . $results['api_a_result'] . "\n";
echo "API B 结果: " . $results['api_b_result'] . "\n";
echo "API C 结果: " . $results['api_c_result'] . "\n";
echo "总耗时: {$duration} 秒\n";

?>

登录后复制

代码解析：

use GuzzleHttp\Promise\Promise; use GuzzleHttp\Promise\Utils;: 导入所需的类。Promise 是核心，Utils 提供了像 all() 这样的辅助函数，用于处理多个Promise。
createAsyncFetchPromise(): 这个函数现在返回一个 Promise 对象。在实际应用中，如果你使用 guzzlehttp/guzzle 库进行HTTP请求，它的 getAsync()、postAsync() 等方法会直接返回Promise。这里我们用 sleep() 和 Utils::queue()->add() 模拟异步行为，以展示Promise的工作方式。
Utils::all([...]): 这是实现并发的关键。它接收一个Promise数组，并返回一个新的Promise。只有当数组中的所有Promise都成功解决后，这个新的Promise才会解决，其结果是一个包含所有子Promise结果的数组。如果任何一个子Promise被拒绝，则 all() 返回的Promise也会立即被拒绝。
$allPromises->wait(): 调用 wait() 方法会强制Promise同步完成并返回其最终结果。这意味着脚本会在这里暂停，直到所有并发请求都完成。

运行这段代码，你会发现总耗时会显著减少。即使每个API请求都可能延迟3秒，但因为它们是“并发”发起的，总耗时将接近最长那个请求的时间（而不是所有请求时间之和），例如，可能只需要3秒多一点！