如何解决PHP异步请求阻塞问题？GuzzleHttp/Promises帮你实现非阻塞编程

<code class="bash">composer require guzzlehttp/promises</code>

<code class="php"><?php

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

use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\Utils; // 用于管理多个 Promise

/**
 * 模拟一个异步操作，返回一个 Promise
 * 在实际应用中，这可能是发起一个 Guzzle HTTP 客户端的异步请求
 */
function simulateAsyncApiCall(string $apiName, int $delaySeconds): Promise
{
    // 创建一个 Promise 对象
    // 这里的匿名函数是 Promise 的 "wait" 函数，它会在 Promise 被等待时执行
    // 但在非阻塞场景下，我们通常通过外部机制（如事件循环）来 resolve/reject Promise
    return new Promise(function ($resolve, $reject) use ($apiName, $delaySeconds) {
        echo "[{$apiName}] 任务开始...\n";

        // 模拟一个耗时操作，例如网络请求或数据库查询
        // 在真正的异步环境中，这里不会阻塞，而是将任务放入事件循环
        // 为了演示 Promise 的管理，我们用一个 setTimeout 或类似机制来模拟延迟后 resolve
        // 在这里，我们简化为立即 resolve，但在实际的异步 HTTP 请求中，Guzzle 会在请求完成后自动 resolve
        // 让我们稍微修改，使其更像一个“未来的结果”
        // 实际的 GuzzleHttp\Client::getAsync() 会返回一个 Promise
        // 这里我们手动创建一个，并模拟其未来的解决
        $startTime = microtime(true);
        // 这是一个同步的 sleep，为了演示 Promise 的概念，我们假设它是一个非阻塞的I/O操作
        // 在一个真实的事件循环中，你不会在这里使用 sleep
        // 而是将 resolve 逻辑放在异步回调中
        // 为了让示例更直观，我们暂时忽略底层真正的异步机制，只关注 Promise 的管理

        // 假设我们有一个机制可以在 $delaySeconds 后调用 $resolve
        // For a simple demo, let's just resolve it immediately to show the chaining/waiting
        // Or, better, use a simpler Promise construction that just resolves.

        // Let's use the provided Promise constructor example for wait()
        // But for multiple promises, we need to resolve them from outside.

        // A better illustrative example for *this* library is to show how you *manage* promises once you have them.
        // Assume you get promises from somewhere (e.g., Guzzle HTTP client's async methods).

        // Let's create a Promise that will be resolved externally.
        $promise = new Promise();

        // Simulate a "future" resolution (e.g., via an event loop, or another thread)
        // For this demo, we'll just resolve it after a short delay in a simplified manner.
        // In a real async framework (like ReactPHP), you'd use a timer.
        // Here, we'll just resolve it immediately for simplicity of demo,
        // and focus on how `then` and `all` work.

        // To make it feel asynchronous in a synchronous script, we'll use a trick:
        // We'll store the promise and resolve it later, simulating concurrent execution.
        // This is where `Utils::all` shines.

        // For this specific example, let's make it simple: a promise that resolves after some "work"
        // This is the core of how `guzzlehttp/promises` works: it manages the *future* state.

        // Let's create a Promise and resolve it after a simulated delay
        // (This is still blocking for the *simulation* part, but the *promise management* is non-blocking)
        $promise->then(function($value) use ($apiName, $startTime, $delaySeconds) {
            $endTime = microtime(true);
            $duration = round($endTime - $startTime, 2);
            echo "[{$apiName}] 任务完成！耗时 {$duration} 秒。结果: {$value}\n";
        });

        // In a real async scenario, the actual work would happen in the background,
        // and then $promise->resolve($result) would be called.
        // For this demo, we'll just resolve it after a "simulated" delay.
        // Let's make the resolution *immediate* for the promise object itself,
        // and show how `Utils::all` manages multiple such promises.

        // Simpler: Just create a promise and resolve it immediately for demonstration of chaining
        // The *actual* async nature comes from *how* the promise is resolved (e.g., from an event loop).

        // Let's create a promise that is resolved after a "simulated" delay (conceptually).
        // For the demo, we'll just resolve it.
        $promise->resolve("数据来自 {$apiName}");
        return $promise; // Return the promise immediately
    });
}

echo "程序开始执行...\n";

// 模拟同时发起两个 API 调用
// 注意：simulateAsyncApiCall 函数本身是同步的，但它返回的 Promise 对象代表了未来的结果。
// 在实际使用 GuzzleHttp 客户端时，getAsync() 等方法会真正发起非阻塞请求。
$promiseA = new Promise(function($resolve) {
    echo "[API-A] 任务开始...\n";
    sleep(2); // 模拟耗时操作
    $resolve("数据来自 API-A");
});

$promiseB = new Promise(function($resolve) {
    echo "[API-B] 任务开始...\n";
    sleep(1); // 模拟耗时操作
    $resolve("数据来自 API-B");
});

// 使用 GuzzleHttp\Promise\Utils::all() 等待所有 Promise 完成
// all() 方法会返回一个新的 Promise，当所有子 Promise 都完成时，这个新的 Promise 才会完成。
// 这时候，wait() 才会真正阻塞，但它阻塞的是所有并发操作的完成，而不是单个操作。
$combinedPromise = Utils::all([$promiseA, $promiseB]);

// 同步等待所有 Promise 完成并获取结果
// wait() 方法会强制 Promise 完成，并返回其最终值或抛出异常。
try {
    $results = $combinedPromise->wait();
    echo "所有任务完成！\n";
    print_r($results);
} catch (Exception $e) {
    echo "任务失败: " . $e->getMessage() . "\n";
}

echo "程序执行完毕。\n";</code>

<code>程序开始执行...
[API-A] 任务开始...
[API-B] 任务开始...
// 大约2秒后
所有任务完成！
Array
(
    [0] => 数据来自 API-A
    [1] => 数据来自 API-B
)
程序执行完毕。</code>