PHP中的`yield from`高级用法：简化Generator与Fiber的委托流程

PHP 中的 yield from 高级用法：简化 Generator 与 Fiber 的委托流程

各位同学，今天我们来深入探讨 PHP 中一个非常强大的特性：yield from。它不仅能简化 Generator 的代码，还能在 Fiber 的场景下发挥重要作用，帮助我们构建更优雅、更易维护的异步流程。

yield from 的基本概念：委托 Generator

在深入高级用法之前，我们先回顾一下 yield from 的基本概念。yield from 实际上是一种 Generator 委托的机制。 简单来说，它可以将一个 Generator 的生成过程委托给另一个 Generator 或实现了 Traversable 接口的对象。

让我们看一个简单的例子：

<?php

function generatorA() {
    yield 1;
    yield 2;
    yield 3;
}

function generatorB() {
    yield 'a';
    yield 'b';
    yield from generatorA(); // 委托给 generatorA
    yield 'c';
}

foreach (generatorB() as $value) {
    echo $value . PHP_EOL;
}

// 输出：
// a
// b
// 1
// 2
// 3
// c

?>

在这个例子中，generatorB 使用 yield from generatorA() 将生成 1, 2, 3 的过程委托给了 generatorA。 当 generatorB 执行到 yield from generatorA() 时，它会暂停执行，直到 generatorA 生成了所有值。然后，generatorB 继续执行后续的代码。

从效果上来说，上面的代码等价于：

<?php

function generatorA() {
    yield 1;
    yield 2;
    yield 3;
}

function generatorB() {
    yield 'a';
    yield 'b';
    foreach (generatorA() as $value) {
        yield $value;
    }
    yield 'c';
}

foreach (generatorB() as $value) {
    echo $value . PHP_EOL;
}

// 输出：
// a
// b
// 1
// 2
// 3
// c

?>

但是，yield from 的优势在于代码的简洁性和可读性。它避免了手动循环遍历被委托的 Generator，使得代码更加清晰。

yield from 与键值对：传递键信息

yield from 还能很好地处理键值对的情况。如果被委托的 Generator yield 的是键值对，那么 yield from 会将键值对完整地传递给外部的迭代器。

<?php

function keyValueGenerator() {
    yield 'key1' => 'value1';
    yield 'key2' => 'value2';
    yield 'key3' => 'value3';
}

function mainGenerator() {
    yield 'before' => 'before_value';
    yield from keyValueGenerator();
    yield 'after' => 'after_value';
}

foreach (mainGenerator() as $key => $value) {
    echo "Key: " . $key . ", Value: " . $value . PHP_EOL;
}

// 输出:
// Key: before, Value: before_value
// Key: key1, Value: value1
// Key: key2, Value: value2
// Key: key3, Value: value3
// Key: after, Value: after_value

?>

在这个例子中，keyValueGenerator 生成的是键值对，mainGenerator 使用 yield from 将这些键值对传递给了外部的 foreach 循环。

yield from 的高级用法：双向数据传递

yield from 不仅仅是简单的委托，它还支持双向的数据传递。这意味着我们可以向被委托的 Generator 发送数据，并且可以接收被委托的 Generator 的返回值。

向被委托的 Generator 发送数据

我们可以使用 Generator::send() 方法向被委托的 Generator 发送数据。被委托的 Generator 可以通过 yield 表达式接收这些数据。

<?php

function subGenerator() {
    $value = yield; // 接收发送过来的数据
    echo "SubGenerator received: " . $value . PHP_EOL;
    yield 'SubGenerator response';
}

function mainGenerator() {
    echo "MainGenerator starting" . PHP_EOL;
    $result = yield from subGenerator();
    echo "MainGenerator received: " . $result . PHP_EOL;
}

$generator = mainGenerator();
$generator->rewind(); // 启动 Generator

$generator->send('Hello from MainGenerator'); // 发送数据给 subGenerator

// 输出:
// MainGenerator starting
// SubGenerator received: Hello from MainGenerator
// MainGenerator received: SubGenerator response

?>

在这个例子中，mainGenerator 使用 yield from subGenerator() 委托了 subGenerator。然后，mainGenerator 使用 $generator->send('Hello from MainGenerator') 向 subGenerator 发送了数据。subGenerator 通过 yield 表达式接收到了这些数据。

接收被委托的 Generator 的返回值

被委托的 Generator 可以使用 return 语句返回值。 yield from 表达式的值就是被委托的 Generator 的返回值。

<?php

function subGenerator() {
    yield 1;
    yield 2;
    return 'SubGenerator finished';
}

function mainGenerator() {
    echo "MainGenerator starting" . PHP_EOL;
    $result = yield from subGenerator();
    echo "MainGenerator received: " . $result . PHP_EOL;
}

foreach(mainGenerator() as $value) {
    echo "Value: " . $value . PHP_EOL;
}

// 输出:
// MainGenerator starting
// Value: 1
// Value: 2
// MainGenerator received: SubGenerator finished

?>

在这个例子中，subGenerator 使用 return 'SubGenerator finished' 返回了一个值。mainGenerator 通过 yield from subGenerator() 接收到了这个返回值。

处理异常

如果被委托的 Generator 抛出了异常，yield from 会将这个异常传递给委托的 Generator。委托的 Generator 可以选择捕获这个异常，或者将它传递给更上层的调用者。

<?php

function subGenerator() {
    yield 1;
    throw new Exception('SubGenerator error');
    yield 2; // 这行代码不会被执行
}

function mainGenerator() {
    try {
        yield from subGenerator();
    } catch (Exception $e) {
        echo "MainGenerator caught exception: " . $e->getMessage() . PHP_EOL;
    }
}

foreach(mainGenerator() as $value) {
    echo "Value: " . $value . PHP_EOL;
}

// 输出:
// Value: 1
// MainGenerator caught exception: SubGenerator error

?>

在这个例子中，subGenerator 抛出了一个异常。mainGenerator 通过 try...catch 块捕获了这个异常。

yield from 在 Fiber 中的应用：简化异步流程

PHP 8.1 引入了 Fiber，它提供了一种创建轻量级协程的方式。yield from 可以很好地与 Fiber 结合使用，简化异步流程的编写。

假设我们有一个异步任务队列，每个任务都是一个 Fiber。我们可以使用 yield from 来委托执行这些 Fiber，并管理它们的生命周期。

<?php

use Fiber;

class Task {
    private Fiber $fiber;
    private mixed $result = null;

    public function __construct(callable $callable) {
        $this->fiber = new Fiber($callable);
    }

    public function run(): mixed {
        if (!$this->fiber->isStarted()) {
            $this->fiber->start();
        }

        if ($this->fiber->isSuspended()) {
            $this->result = $this->fiber->resume();
        }

        return $this->result;
    }

    public function isFinished(): bool {
        return $this->fiber->isTerminated();
    }

    public function getResult(): mixed {
        return $this->fiber->getReturn();
    }
}

function asyncTask(string $name, int $duration) {
    echo "Task {$name} started" . PHP_EOL;
    sleep($duration);
    echo "Task {$name} finished" . PHP_EOL;
    return "Result from {$name}";
}

function taskRunner() {
    $task1 = new Task(fn() => asyncTask('Task 1', 2));
    $task2 = new Task(fn() => asyncTask('Task 2', 1));

    yield $task1;
    yield $task2;
}

function scheduler() {
    foreach (taskRunner() as $task) {
        /** @var Task $task */
        while (!$task->isFinished()) {
            $result = $task->run();
            if($result !== null){
                echo "Task yielded {$result}" . PHP_EOL;
            }
            // Simulate I/O waiting
            usleep(100000);
        }
        echo "Task completed with result: " . $task->getResult() . PHP_EOL;
    }
}

scheduler();

// 可能的输出 (顺序可能不同):
// Task Task 1 started
// Task Task 2 started
// Task yielded null
// Task yielded null
// Task yielded null
// Task 2 finished
// Task yielded null
// Task completed with result: Result from Task 2
// Task yielded null
// Task 1 finished
// Task completed with result: Result from Task 1
?>

在这个例子中，taskRunner 函数创建了两个 Task 对象，每个 Task 对象都包含一个 Fiber。scheduler 函数使用 foreach 循环遍历 taskRunner 生成的 Task 对象，并执行它们。asyncTask 模拟了一个异步任务，使用 sleep 函数模拟 I/O 等待。

现在，我们可以使用 yield from 来简化 scheduler 函数的实现。

<?php

use Fiber;

class Task {
    private Fiber $fiber;
    private mixed $result = null;

    public function __construct(callable $callable) {
        $this->fiber = new Fiber($callable);
    }

    public function run(): mixed {
        if (!$this->fiber->isStarted()) {
            $this->fiber->start();
        }

        if ($this->fiber->isSuspended()) {
            $this->result = $this->fiber->resume();
        }

        return $this->result;
    }

    public function isFinished(): bool {
        return $this->fiber->isTerminated();
    }

    public function getResult(): mixed {
        return $this->fiber->getReturn();
    }

    public function yieldFromFiber(): mixed {
        while (!$this->isFinished()) {
            $result = $this->run();
            yield $result; // Yield the result of the Fiber's execution step
        }
        return $this->getResult(); // Return the final result
    }
}

function asyncTask(string $name, int $duration) {
    echo "Task {$name} started" . PHP_EOL;
    sleep($duration);
    echo "Task {$name} finished" . PHP_EOL;
    return "Result from {$name}";
}

function taskRunner() {
    $task1 = new Task(fn() => asyncTask('Task 1', 2));
    $task2 = new Task(fn() => asyncTask('Task 2', 1));

    yield $task1;
    yield $task2;
}

function scheduler() {
    foreach (taskRunner() as $task) {
        /** @var Task $task */
        $result = yield from $task->yieldFromFiber();
        echo "Task completed with result: " . $result . PHP_EOL;
    }
}

foreach(scheduler() as $yieldedValue){
    if($yieldedValue !== null){
        echo "Task yielded {$yieldedValue}" . PHP_EOL;
    }
    usleep(100000);
}

// 可能的输出 (顺序可能不同):
// Task Task 1 started
// Task Task 2 started
// Task yielded null
// Task yielded null
// Task yielded null
// Task 2 finished
// Task yielded null
// Task completed with result: Result from Task 2
// Task yielded null
// Task 1 finished
// Task completed with result: Result from Task 1
?>

在这个改进后的例子中，我们在 Task 类中添加了一个 yieldFromFiber 方法。 这个方法使用 while 循环执行 Fiber，并使用 yield 语句将 Fiber 的执行结果传递给调用者。 scheduler 函数现在可以使用 yield from $task->yieldFromFiber() 来委托执行 Fiber，并接收 Fiber 的最终返回值。 scheduler 函数本身成为了一个 Generator， 允许我们模拟 I/O 等待，并处理中间结果。

这种方式简化了 scheduler 函数的实现，使代码更加清晰易懂。 yield from 将 Fiber 的执行细节隐藏在了 Task 类中，使得 scheduler 函数可以专注于任务的调度。

实际应用场景

yield from 在实际开发中有很多应用场景，例如：

• 构建复杂的 Generator 流程：可以使用 yield from 将复杂的 Generator 流程分解成更小的、更易于管理的子 Generator。
• 实现异步迭代器：可以使用 yield from 来委托执行异步任务，并生成异步迭代器。
• 简化状态机：可以使用 yield from 来委托执行状态机的各个状态，并管理状态之间的转换。
• 处理大量数据：可以使用 yield from 将数据分块处理，避免一次性加载所有数据到内存中。
• 实现 Actor 模型：可以结合 Fiber 和 yield from 实现 Actor 模型，构建高并发的应用。

性能考量

虽然 yield from 提供了很多便利，但在使用时也需要考虑性能问题。 yield from 本身会带来一定的性能开销，因为它需要维护 Generator 的状态，并在 Generator 之间切换执行。

在性能敏感的场景中，需要仔细评估 yield from 的使用是否会影响应用的性能。 可以考虑使用其他方式来实现相同的功能，例如手动循环遍历 Generator，或者使用更底层的异步 API。

yield from 的优势总结

特性	描述
代码简洁性	避免手动循环遍历被委托的 Generator，使得代码更加清晰易懂。
可读性	提高了代码的可读性，使得代码更容易理解和维护。
双向数据传递	支持向被委托的 Generator 发送数据，并接收被委托的 Generator 的返回值。
异常处理	可以将异常从被委托的 Generator 传递给委托的 Generator。
Fiber 集成	可以很好地与 Fiber 结合使用，简化异步流程的编写。
任务调度	能够构建更清晰的任务调度逻辑，将异步任务的执行细节封装在Task类中，并通过yield from 将控制权交还给调度器，从而允许模拟I/O等待，并更好地管理任务生命周期。

充分利用委托，构建更强大的功能

yield from 是 PHP 中一个非常强大的特性，它可以简化 Generator 和 Fiber 的代码，并提高代码的可读性和可维护性。 通过灵活运用 yield from，我们可以构建更优雅、更高效的异步应用。 掌握 yield from 的高级用法，可以帮助我们更好地理解 PHP 的 Generator 和 Fiber，并构建更强大的功能。希望今天的讲解能够帮助大家更好地理解和使用 yield from。