告别漫长等待：如何使用Composer与GuzzlePromises解决PHP并发瓶颈

<code class="php">$userData = fetch_user_profile_api(); // 等待1秒
$orderData = fetch_order_details_api(); // 等待1.5秒
$stockData = fetch_stock_info_api(); // 等待0.8秒

// 总耗时：1 + 1.5 + 0.8 = 3.3秒</code>

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

<code class="php"><?php

require 'vendor/autoload.php';

use GuzzleHttp\Promise\Promise;
use GuzzleHttp\Promise\RejectedPromise;

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

// 模拟一个异步操作，比如API调用
function simulateAsyncTask(string $taskName, int $delaySeconds, bool $shouldFail = false): Promise
{
    return new Promise(function () use (&$promise, $taskName, $delaySeconds, $shouldFail) {
        // 在这里，你可以发起一个真正的异步请求，比如一个非阻塞的HTTP请求
        // 为了演示，我们用一个延时来模拟耗时操作
        echo "任务 '{$taskName}' 开始执行，预计等待 {$delaySeconds} 秒...\n";

        // 实际应用中，这里会是非阻塞的I/O操作
        // 比如 GuzzleHttp\Client 的 async 方法

        // 模拟异步完成或失败
        if ($shouldFail) {
            // 模拟失败
            $promise->reject(new Exception("任务 '{$taskName}' 失败了！"));
        } else {
            // 模拟成功
            $promise->resolve("任务 '{$taskName}' 完成了，耗时 {$delaySeconds} 秒。");
        }
    });
}

// 创建三个异步任务的Promise
$promise1 = simulateAsyncTask('用户数据', 2);
$promise2 = simulateAsyncTask('订单数据', 1.5);
$promise3 = simulateAsyncTask('库存数据', 0.8, true); // 模拟一个失败的任务

// 使用 then() 注册回调，处理每个Promise的结果
$promise1->then(
    function ($value) {
        echo "成功处理：{$value}\n";
    },
    function ($reason) {
        echo "失败处理：用户数据 - " . $reason->getMessage() . "\n";
    }
);

$promise2->then(
    function ($value) {
        echo "成功处理：{$value}\n";
    },
    function ($reason) {
        echo "失败处理：订单数据 - " . $reason->getMessage() . "\n";
    }
);

$promise3->then(
    function ($value) {
        echo "成功处理：{$value}\n";
    },
    function ($reason) {
        echo "失败处理：库存数据 - " . $reason->getMessage() . "\n";
    }
);

// Guzzle Promises 在内部使用一个任务队列来异步地处理回调。
// 在非事件循环环境中（如Web请求），你需要手动运行这个队列来确保Promise被解析。
// 对于Guzzle HTTP客户端，它的异步请求会自动处理这个。
// 但对于手动创建的Promise，或在没有事件循环的脚本中，需要调用 Utils::queue()->run()
// 或直接使用 wait() 方法来强制Promise完成。
// 为了演示效果，我们使用 wait() 来等待所有Promise完成。
// 注意：wait() 会阻塞当前进程直到Promise完成，所以它将等待最长的那个Promise。
// 在实际并发场景，你会使用 GuzzleHttp\Promise\Utils::all() 或 GuzzleHttp\Promise\Utils::settle()
// 来等待一组Promise，并在它们全部完成（无论成功失败）后继续执行。

echo "等待所有任务完成...\n";

try {
    // 实际应用中，如果需要等待所有 Promise 都完成，会用 GuzzleHttp\Promise\Utils::all()
    // 这里为了简单演示，我们单独等待，但请注意这会串行等待
    // 更常见的用法是：
    // GuzzleHttp\Promise\Utils::all([$promise1, $promise2, $promise3])->wait();
    // 这样会并行地等待所有 Promise，并阻塞直到所有都完成。

    // 我们手动触发 Promise 的 resolve/reject，因此无需额外的事件循环或 wait()
    // 如果 simulateAsyncTask 内部真的有异步操作，那么这里就需要一个事件循环或 wait()
    // 比如：
    // $results = GuzzleHttp\Promise\Utils::all([$promise1, $promise2, $promise3])->wait();
    // var_dump($results);

    // 因为我们的 simulateAsyncTask 是同步 resolve/reject 的，所以回调会立即执行
    // 如果是真正的异步，需要一个事件循环或 wait() 来驱动
    // 这里我们只是让程序继续执行，观察回调输出

} catch (Exception $e) {
    echo "捕获到异常： " . $e->getMessage() . "\n";
}

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

<code class="php">$promise = simulateAsyncTask('第一步', 1)
    ->then(function ($value) {
        echo "第一步完成：{$value}\n";
        return simulateAsyncTask('第二步', 0.5); // 返回一个新的Promise
    })
    ->then(function ($value) {
        echo "第二步完成：{$value}\n";
        return "所有步骤完成！"; // 返回一个普通值
    })
    ->then(function ($value) {
        echo "最终结果：{$value}\n";
    })
    ->otherwise(function ($reason) { // 捕获链中任何环节的错误
        echo "链式操作中出现错误：" . $reason->getMessage() . "\n";
    });

// GuzzleHttp\Promise\Utils::queue()->run(); // 如果没有 wait() 或 GuzzleHttp\Client 驱动，需要手动运行任务队列
$promise->wait(); // 阻塞等待整个链完成</code>