PHP异步编程的痛点如何解决？使用Composer与GuzzlePromise实现高效非阻塞操作

<pre class="brush:php;toolbar:false;">// 伪代码示例
$weatherData = call_api_sync('weather_api_url'); // 等待天气API响应
$stockData = call_api_sync('stock_api_url');   // 等待股票API响应
$newsData = call_api_sync('news_api_url');     // 等待新闻API响应

// 聚合数据并返回
return combine_data($weatherData, $stockData, $newsData);

guzzlehttp/promises

guzzlehttp/promises

<pre class="brush:php;toolbar:false;">composer require guzzlehttp/promises

guzzlehttp/promises

guzzlehttp/promises

fulfilled

rejected

<pre class="brush:php;toolbar:false;"><?php

require 'vendor/autoload.php';

use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\Utils; // 用于并发等待所有Promise

// 模拟一个耗时的异步API调用函数
function mockAsyncApiCall(string $name, int $delayMs): Promise
{
    $promise = new Promise();
    // 实际项目中，这里会是发起HTTP请求等非阻塞操作
    // 比如 GuzzleHttp\Client 的 async 方法
    // 这里我们用一个定时器模拟异步
    echo "[$name] 开始请求...\n";

    // 假设这是一个真正的异步操作，结果会在未来某个时刻返回
    // 我们可以通过 resolve 或 reject 来兑现 Promise
    // 在这里，我们为了演示，会手动调用 resolve
    // 实际应用中，通常是HTTP客户端或其他异步库来完成这一步

    // 为了模拟异步，我们在这里简单地延迟，并立即resolve，
    // 真实场景下，Guzzle HTTP客户端的异步请求会返回一个Promise
    // 并且在请求完成后自动resolve/reject

    // 为了更接近实际的异步场景，我们可以这样构造一个立即resolve的Promise
    // 或者在Guzzle HTTP客户端中直接使用其返回的Promise
    // 这里为了清晰演示Promise概念，我们手动resolve
    \Swoole\Coroutine::create(function () use ($promise, $name, $delayMs) {
        \Swoole\Coroutine::sleep($delayMs / 1000); // 模拟延迟
        $promise->resolve("{$name} 数据已获取 (延迟{$delayMs}ms)");
    });

    return $promise;
}

// 创建多个Promise，代表多个异步操作
$weatherPromise = mockAsyncApiCall('天气', 1500);
$stockPromise = mockAsyncApiCall('股票', 1000);
$newsPromise = mockAsyncApiCall('新闻', 2000);

// 使用 GuzzleHttp\Promise\Utils::all() 等待所有Promise完成
// all() 方法会返回一个新的Promise，当所有输入的Promise都成功时，它才成功
// 任何一个Promise失败，它就失败
$allPromises = Utils::all([
    'weather' => $weatherPromise,
    'stock'   => $stockPromise,
    'news'    => $newsPromise,
]);

// 注册回调，处理所有Promise成功后的结果
$allPromises->then(
    function (array $results) {
        echo "所有数据都已获取！\n";
        foreach ($results as $key => $value) {
            echo "{$key}: {$value}\n";
        }
        echo "聚合完成，总耗时大大缩短！\n";
    },
    function (\Throwable $reason) {
        echo "有Promise被拒绝了: " . $reason->getMessage() . "\n";
    }
);

// 注意：在没有事件循环的情况下，我们需要手动运行Promise的调度器
// 或者使用 wait() 方法强制同步等待（这会失去部分异步优势，但确保结果）
// 对于Guzzle Promises，如果不是在事件循环中，通常需要一个主循环来驱动
// 对于简单脚本，或者在Guzzle HTTP客户端场景，可以直接使用 wait()
// 这里为了演示，我们假设在一个支持异步调度的环境中运行，或者最后调用 wait()

// 如果没有Swoole/ReactPHP等事件循环，你需要手动触发Promise的调度
// 或者使用 wait() 方法强制同步等待，但这样会阻塞
// $allPromises->wait(); // 如果你需要强制同步等待结果

// 为了在没有完整事件循环的简单脚本中看到效果，我们这里使用一个简单的等待机制
// 实际应用中，Guzzle HTTP客户端会自动处理其内部Promise的调度
// 或者在事件循环（如ReactPHP、Swoole）中集成Guzzle Promise
// 运行这个脚本需要一个支持协程或异步的PHP环境，例如Swoole
// 如果没有Swoole，可以把 mockAsyncApiCall 替换成 GuzzleHttp\Client 的 async 方法
// 然后调用 $allPromises->wait() 来同步获取结果，但这样就不是真正的非阻塞了。

echo "主程序继续执行，无需等待！\n";
// 在这里，主程序可以继续处理其他事情，而不需要等待API响应
// 只有当需要聚合所有结果时，才会等待 Promise 完成。

// 为了演示，我们在这里模拟一个简单的等待，直到所有Promise完成
// 实际生产中，Guzzle Promises会与Guzzle HTTP客户端或其他异步库无缝集成
// 并且通常在一个事件循环中运行。
// 这里为了让脚本能执行并显示结果，我们简单地等待一下
// 如果在真实异步环境，不需要这个循环
// for ($i = 0; $i < 30; $i++) {
//     \Swoole\Coroutine::sleep(0.1);
//     // 在真实异步环境中，这里会运行Promise调度器
//     // GuzzleHttp\Promise\Utils::queue()->run();
// }
// 实际上，Guzzle Promises在没有事件循环时，通常需要你手动调用 wait() 来驱动
// 或者使用 Guzzle HTTP 客户端，它会为你处理这些细节。

// 为了让这个简单的脚本能看到结果，我们强制同步等待
// 这虽然失去了完全非阻塞的优势，但能确保结果的显示
// 在实际使用 Guzzle HTTP 客户端时，其异步方法返回的Promise，
// 最终可以通过 wait() 来获取结果，或者与其他Promise组合。
try {
    $finalResults = $allPromises->wait(); // 强制等待所有Promise完成
    echo "最终结果通过 wait() 获取:\n";
    foreach ($finalResults as $key => $value) {
        echo "{$key}: {$value}\n";
    }
} catch (\Throwable $e) {
    echo "通过 wait() 获取结果时发生错误: " . $e->getMessage() . "\n";
}

Utils::all()

then()

all()

guzzlehttp/promises