PHP `Amp` 异步编程框架：`Promise`、`Generator` 与 `Watcher`

各位观众老爷们，大家好！今天咱们来聊聊 PHP 的异步编程框架 Amp，重点攻克 Promise、Generator 和 Watcher 这三个听起来高大上，实际上摸透了也就那么回事儿的核心概念。

Amp，这玩意儿就像一个“多线程管理员”，它让你的 PHP 代码看起来像是在“同时”做很多事情，但实际上并没有真正的多线程（PHP 本身也不太擅长这个）。它利用了事件循环（Event Loop）来实现并发，从而提升性能，尤其是在处理 I/O 密集型任务时效果显著。

先来个总览，看看这三位主角在 Amp 的异步世界里扮演什么角色：

组件	职责	比喻
`Promise`	代表一个异步操作的未来结果。你可以理解为“承诺”，一个将来会兑现的承诺，要么成功，要么失败。	一张彩票，你现在买了，但结果要过几天才知道。
`Generator`	一种特殊的函数，可以被暂停和恢复执行。在 Amp 中，它可以让你用同步的方式编写异步代码，让代码更易读。	一个“暂停”按钮，你可以随时按下，然后过一段时间再按“继续”按钮。
`Watcher`	负责监听 I/O 事件（例如：socket 可读、可写），当事件发生时，通知相应的 `Promise` 或 `Generator` 继续执行。	负责“盯梢”的侦探，一旦发现目标人物（I/O 事件）出现，就立刻发出信号。

好了，有了这个概念性的认识，咱们逐个击破。

一、Promise：未来的承诺

Promise 代表着一个异步操作的最终结果。它有三种状态：

Pending（等待中）： 异步操作尚未完成。
Fulfilled（已成功）： 异步操作已成功完成，并且有了一个结果值。
Rejected（已失败）： 异步操作失败，并且有一个失败原因。

你可以把 Promise 想象成一个“欠条”，上面写着“将来某时会给你多少钱”。现在你手里拿着这个欠条，但还没拿到钱，这就是 Pending 状态。等到还款日，如果顺利拿到钱，Promise 就变成了 Fulfilled 状态，你也就得到了结果值（钱）。如果对方跑路了，Promise 就变成了 Rejected 状态，你也就得到了失败的原因（对方跑路）。

来看一个简单的例子：

<?php

use AmpPromise;
use AmpSuccess;
use AmpFailure;

require __DIR__ . '/vendor/autoload.php';

// 一个立即成功的 Promise
$successPromise = new Success(42);

// 一个立即失败的 Promise
$failurePromise = new Failure(new Exception("Something went wrong!"));

// 使用 then() 方法处理 Promise 的结果
$successPromise->then(
    function ($value) {
        echo "Success: " . $value . PHP_EOL; // 输出：Success: 42
    },
    function (Throwable $reason) {
        echo "Failure: " . $reason->getMessage() . PHP_EOL;
    }
);

$failurePromise->then(
    function ($value) {
        echo "Success: " . $value . PHP_EOL;
    },
    function (Throwable $reason) {
        echo "Failure: " . $reason->getMessage() . PHP_EOL; // 输出：Failure: Something went wrong!
    }
);

// 创建一个延迟执行的 Promise
$deferred = new AmpDeferred();
$promise = $deferred->promise();

$promise->then(
    function ($value) {
        echo "Deferred Success: " . $value . PHP_EOL;
    },
    function (Throwable $reason) {
        echo "Deferred Failure: " . $reason->getMessage() . PHP_EOL;
    }
);

// 在稍后的某个时间点，解决 (resolve) Promise
AmpLoop::delay(1000, function () use ($deferred) {
    $deferred->resolve("Hello from deferred!");
});

// 运行事件循环
AmpLoop::run();

?>

解释一下：

Success 和 Failure 是 Promise 的两个实现类，分别代表立即成功和立即失败的 Promise。
then() 方法用于注册成功和失败的回调函数。当 Promise 的状态变为 Fulfilled 时，成功回调函数会被执行；当 Promise 的状态变为 Rejected 时，失败回调函数会被执行。
Deferred 类用于创建一个 Promise，但是这个 Promise 的状态一开始是 Pending，需要手动调用 resolve() 或 reject() 方法来改变它的状态。
AmpLoop::delay() 函数用于在指定的时间后执行一个回调函数。这里我们用它来模拟一个异步操作，在 1 秒后解决 (resolve) Promise。
AmpLoop::run() 启动事件循环，开始监听 I/O 事件和执行回调函数。

Promise 的核心就是 then() 方法，它允许你链式调用，形成一个异步操作的流水线。例如：

<?php

use AmpLoop;
use AmpPromise;
use AmpSuccess;
use AmpFailure;

require __DIR__ . '/vendor/autoload.php';

$promise = new Success(10);

$promise->then(function ($value) {
    echo "First: " . $value . PHP_EOL; // First: 10
    return $value * 2;
})->then(function ($value) {
    echo "Second: " . $value . PHP_EOL; // Second: 20
    return $value + 5;
})->then(function ($value) {
    echo "Third: " . $value . PHP_EOL; // Third: 25
})->catch(function (Throwable $reason) {
    echo "Error: " . $reason->getMessage() . PHP_EOL;
});

Loop::run();

?>

在这个例子中，我们创建了一个 Success 的 Promise，然后通过 then() 方法进行链式调用。每个 then() 方法都会返回一个新的 Promise，它的结果值是上一个 then() 方法的回调函数的返回值。如果任何一个 then() 方法抛出异常，catch() 方法会被执行。

二、Generator：同步的异步

Generator 是 PHP 5.5 引入的一个特性，它允许你编写可以被暂停和恢复执行的函数。在 Amp 中，Generator 被用来以同步的方式编写异步代码。

你可以把 Generator 想象成一个“分段式程序”，它把一个复杂的任务分解成多个小步骤，每个步骤之间都可以暂停和恢复。

来看一个例子：

<?php

use AmpLoop;
use AmpPromise;
use AmpSuccess;
use AmpCoroutine;

require __DIR__ . '/vendor/autoload.php';

function fetchUrl(string $url): Promise
{
    // 模拟一个异步 HTTP 请求
    $deferred = new AmpDeferred();

    Loop::delay(500, function () use ($deferred, $url) {
        // 假设请求成功
        $deferred->resolve("Content of " . $url);
    });

    return $deferred->promise();
}

function* myCoroutine()
{
    echo "Fetching URL 1...n";
    $content1 = yield fetchUrl("https://example.com/1"); // 暂停执行，等待 Promise 完成
    echo "Content 1: " . $content1 . "n";

    echo "Fetching URL 2...n";
    $content2 = yield fetchUrl("https://example.com/2"); // 暂停执行，等待 Promise 完成
    echo "Content 2: " . $content2 . "n";

    return "All done!";
}

$coroutine = new Coroutine(myCoroutine()); // 将 Generator 包装成 Coroutine
$coroutine->then(function ($result) {
    echo "Result: " . $result . "n"; // 输出：Result: All done!
});

Loop::run();

解释一下：

fetchUrl() 函数模拟一个异步 HTTP 请求，它返回一个 Promise。
myCoroutine() 函数是一个 Generator，它使用 yield 关键字来暂停执行，并等待一个 Promise 完成。
Coroutine 类用于将一个 Generator 包装成一个 Promise。当 Generator 执行完毕时，Coroutine 的 Promise 就会被解决 (resolve)。
在 Generator 中，你可以像编写同步代码一样编写异步代码，而不需要显式地使用回调函数。这使得代码更易读和易维护。

yield 关键字是 Generator 的核心。它允许你暂停 Generator 的执行，并返回一个值。当 yield 的值是一个 Promise 时，Generator 会暂停执行，直到 Promise 完成。然后，Generator 会恢复执行，并将 Promise 的结果值作为 yield 表达式的值。

三、Watcher：事件的侦探

Watcher 负责监听 I/O 事件，并在事件发生时通知相应的 Promise 或 Generator 继续执行。在 Amp 中，Watcher 通常与 Stream 类一起使用，用于处理网络 I/O。

你可以把 Watcher 想象成一个“侦探”，它负责“盯梢”某个 I/O 事件（例如：socket 可读、可写），一旦发现目标人物（I/O 事件）出现，就立刻发出信号。

来看一个简单的例子：

<?php

use AmpLoop;
use AmpSocket;
use AmpPromise;
use AmpSuccess;

require __DIR__ . '/vendor/autoload.php';

Loop::run(function () {
    $server = Socketlisten("tcp://127.0.0.1:1337");

    echo "Listening on " . $server->getAddress() . "...n";

    while ($socket = yield $server->accept()) {
        Loop::defer(function () use ($socket) {
            $data = yield $socket->read();
            echo "Received: " . $data . "n";

            yield $socket->write("Hello, " . $data);
            $socket->close();
        });
    }
});

解释一下：

Socketlisten() 函数创建一个 TCP 服务器，监听指定的地址和端口。
$server->accept() 返回一个 Promise，当有新的连接到达时，这个 Promise 就会被解决 (resolve)，并返回一个 Socket 对象。
$socket->read() 返回一个 Promise，当 socket 可读时，这个 Promise 就会被解决 (resolve)，并返回读取到的数据。
$socket->write() 返回一个 Promise，当 socket 可写时，这个 Promise 就会被解决 (resolve)，并返回写入的字节数。
$socket->close() 关闭 socket 连接。

在这个例子中，Watcher 负责监听 socket 的可读和可写事件。当 socket 可读时，Watcher 会通知 read() 方法继续执行；当 socket 可写时，Watcher 会通知 write() 方法继续执行。

总结：三剑客的协作

Promise、Generator 和 Watcher 这三个组件在 Amp 中协同工作，共同构建了一个高效的异步编程模型。

Promise 负责表示异步操作的未来结果。
Generator 允许你以同步的方式编写异步代码。
Watcher 负责监听 I/O 事件，并在事件发生时通知相应的 Promise 或 Generator 继续执行。

这三者之间的关系可以用一个简单的流程图来表示：

[用户代码] --> [Generator (使用 yield 暂停)] --> [Promise (代表异步操作)] --> [Watcher (监听 I/O 事件)] --> [I/O 事件发生] --> [Promise 解决 (resolve) / 拒绝 (reject)] --> [Generator 恢复执行] --> [用户代码]

一些更实际的例子：

并发 HTTP 请求：

<?php

use AmpLoop;
use AmpArtaxClientBuilder;
use AmpArtaxRequest;

require __DIR__ . '/vendor/autoload.php';

Loop::run(function () {
    $client = (new ClientBuilder)->build();

    $urls = [
        "https://www.example.com",
        "https://www.google.com",
        "https://www.github.com",
    ];

    $promises = [];
    foreach ($urls as $url) {
        $promises[$url] = $client->request(new Request($url));
    }

    foreach ($promises as $url => $promise) {
        try {
            $response = yield $promise;
            echo "{$url}: " . $response->getStatus() . " " . $response->getReason() . "n";
        } catch (Throwable $e) {
            echo "{$url}: " . $e->getMessage() . "n";
        }
    }
});

这个例子使用 AmpArtax HTTP 客户端并发地发送多个 HTTP 请求。AmpArtax 本身就是基于 Amp 构建的，所以可以很好地利用 Amp 的异步特性。

数据库查询：

<?php

use AmpLoop;
use AmpMysqlMysqlConnectionPool;
use AmpMysqlMysqlConfig;

require __DIR__ . '/vendor/autoload.php';

Loop::run(function () {
    $config = new MysqlConfig("localhost:3306", "your_user", "your_password", "your_database");
    $pool = new MysqlConnectionPool($config);

    try {
        $connection = yield $pool->getConnection();

        $result = yield $connection->query("SELECT * FROM your_table");

        while (yield $result->advance()) {
            $row = $result->getCurrent();
            print_r($row);
        }

        $pool->release($connection);

    } catch (Throwable $e) {
        echo "Error: " . $e->getMessage() . "n";
    } finally {
        yield $pool->close();
    }
});

这个例子使用 AmpMysql 库异步地执行数据库查询。AmpMysql 也是基于 Amp 构建的，可以让你在 PHP 中高效地操作 MySQL 数据库。替换 your_user, your_password, your_database 和 your_table 为你自己的数据库信息。

一些小贴士和注意事项：

错误处理： 在异步代码中，错误处理非常重要。一定要使用 try...catch 块来捕获异常，并进行适当的处理。
取消 (Cancellation)： 有时候，你可能需要取消一个正在进行的异步操作。Amp 提供了一些机制来实现取消，例如 CancellationToken。
上下文 (Context)： 在异步代码中，要注意上下文的传递。例如，如果你在一个协程 (Coroutine) 中使用了全局变量，要确保在协程恢复执行时，全局变量的值仍然是正确的。
调试： 异步代码的调试比较困难。Amp 提供了一些工具来帮助你调试异步代码，例如 Amptrace() 函数可以打印协程的执行堆栈。

总结：

Amp 是一个强大的 PHP 异步编程框架，它可以让你编写高性能的应用程序。虽然 Promise、Generator 和 Watcher 听起来有些复杂，但只要你理解了它们的基本概念和工作原理，就能轻松地使用 Amp 来构建异步应用。记住，多练习，多实践，你就能成为 Amp 异步编程的高手！

今天就到这里，希望对大家有所帮助！下次再见！

发表回复 取消回复

发表回复取消回复