PHP7에서 코루틴 구현에 대해 자세히 논의

머리말

모든 사람이 "코루틴"이라는 개념을 들어본 적이 있을 것입니다.

하지만 어떤 학생들은 이 개념을 이해하지 못하고, 어떻게 구현하고, 어떻게 사용하고, 어디에 사용하는지 모르기도 합니다. 심지어 어떤 사람들은 Yield가 코루틴이라고 생각하기도 합니다!

저는 지식 포인트를 정확하게 표현하지 못하면 그냥 이해하지 못한 것이라고 생각할 수 있다고 늘 믿습니다.

이전에 PHP를 사용하여 코루틴을 구현하는 방법을 배웠다면 Niao 형제의 기사를 읽어 보셨을 것입니다. PHP에서 코루틴을 사용하여 다중 작업 스케줄링 구현 | Fengxue의 코너

Brother Niao의 이 기사는 해외에서 번역되었습니다. 저자의 설명에 따르면 번역은 간결하고 명확하며 구체적인 예도 제시되어 있습니다.

이 글을 쓰는 목적은 브라더버드의 글을 좀 더 완벽하게 보충하기 위한 것입니다. 결국 일부 학생들의 기초가 충분하지 않아 혼란스럽습니다.

코루틴이 무엇인가요?

먼저 코루틴이 무엇인지 알아보겠습니다.

"프로세스"와 "스레드"라는 개념을 들어보셨을 것입니다.

프로세스는 .exe 파일이 클래스이고 프로세스가 새 인스턴스인 것처럼 컴퓨터 메모리에서 실행 중인 바이너리 실행 파일의 인스턴스입니다.

프로세스는 컴퓨터 시스템의 리소스 할당 및 예약을 위한 기본 단위입니다(예약 단위인 스레드 프로세스에 대해 걱정하지 마세요). 각 CPU는 한 번에 하나의 프로세스만 처리할 수 있습니다.

소위 병렬 처리는 병렬적으로만 보입니다. CPU는 실제로 서로 다른 프로세스 간에 매우 빠르게 전환합니다.

프로세스 전환에는 시스템 호출이 필요합니다. CPU는 현재 프로세스에 대한 다양한 정보를 저장해야 하며 CPUCache도 파괴됩니다.

따라서 프로세스를 전환할 수 없다면 꼭 필요한 경우가 아니면 전환하지 마세요.

그럼 "꼭 필요한 경우가 아니면 프로세스 전환을 수행하지 않음"을 어떻게 달성할 수 있나요?

먼저 프로세스가 전환되는 조건은 프로세스 실행 완료, 프로세스에 할당된 CPU 타임 슬라이스 종료, 처리해야 할 시스템에 인터럽트가 발생하거나 프로세스가 대기 중인 경우입니다. 필요한 자원(프로세스 차단) 등 생각해보면 앞선 상황에서는 할 말이 없는데 막고 기다리면 아깝지 않나?

실제로 차단된 경우 프로그램이 실행될 다른 실행 가능한 위치가 있으므로 어리석게 기다릴 필요가 없습니다!

그래서 스레드가 있습니다.

스레드를 간단히 이해하면 특정 기능(논리적 흐름)을 실행하는 "마이크로 프로세스"입니다.

그래서 스레드를 사용하여 프로그램 작성 과정에서 동시에 실행될 수 있는 기능을 나타낼 수 있습니다.

스레드에는 두 가지 유형이 있는데, 하나는 커널에 의해 관리되고 예약됩니다.

커널이 관리와 스케줄링에 관여하는 한 비용이 매우 높다고 합니다. 이러한 종류의 스레드는 실제로 프로세스에서 실행 중인 스레드가 막히는 경우 다른 실행 가능한 스레드가 실행되도록 예약할 수 있지만 여전히 동일한 프로세스에 있으므로 프로세스 전환이 없다는 문제를 해결합니다.

프로그램을 직접 작성하는 프로그래머가 스케줄링을 관리하고 커널에는 보이지 않는 또 다른 종류의 스레드가 있습니다. 이런 종류의 스레드를 "사용자 공간 스레드"라고 합니다.

코루틴은 일종의 사용자 공간 스레드로 이해될 수 있습니다.

코루틴에는 여러 가지 특징이 있습니다.

• 협업, 프로그래머가 직접 작성한 스케줄링 전략이므로 선점 대신 협력을 통해 전환합니다.
• 생성, 전환 및 소멸이 사용자 모드에서 완료됩니다
• ⚠️ 프로그래밍 관점에서 볼 때, 코루틴의 아이디어는 본질적으로 제어 흐름의 활성 항복 및 재개 메커니즘입니다
• 제너레이터는 코루틴을 구현하는 데 자주 사용됩니다

이렇게 말했으니 이해해야 합니다. 코루틴의 기본 개념을 이해하고 있나요?

PHP는 코루틴을 구현합니다

개념 설명부터 단계별로 시작해보세요!

반복 가능한 객체

PHP5는 foreach 문을 사용하는 것과 같이 셀 목록을 통해 탐색할 수 있도록 객체를 정의하는 방법을 제공합니다. foreach语句。

你如果要实现一个可迭代对象，你就要实现Iterator接口：

<?php
class MyIterator implements Iterator
{
    private $var = array();

    public function __construct($array)
    {
        if (is_array($array)) {
            $this->var = $array;
        }
    }

    public function rewind() {
        echo "rewinding\n";
        reset($this->var);
    }

    public function current() {
        $var = current($this->var);
        echo "current: $var\n";
        return $var;
    }

    public function key() {
        $var = key($this->var);
        echo "key: $var\n";
        return $var;
    }

    public function next() {
        $var = next($this->var);
        echo "next: $var\n";
        return $var;
    }

    public function valid() {
        $var = $this->current() !== false;
        echo "valid: {$var}\n";
        return $var;
    }
}

$values = array(1,2,3);
$it = new MyIterator($values);

foreach ($it as $a => $b) {
    print "$a: $b\n";
}

   

生成器

可以说之前为了拥有一个能够被foreach遍历的对象，你不得不去实现一堆的方法，yield关键字就是为了简化这个过程。

生成器提供了一种更容易的方法来实现简单的对象迭代，相比较定义类实现Iterator接口的方式，性能开销和复杂性大大降低。

<?php
function xrange($start, $end, $step = 1) {
    for ($i = $start; $i <= $end; $i += $step) {
        yield $i;
    }
}
 
foreach (xrange(1, 1000000) as $num) {
    echo $num, "\n";
}

记住，一个函数中如果用了yield，他就是一个生成器，直接调用他是没有用的，不能等同于一个函数那样去执行！

所以，yield就是yield，下次谁再说yield

반복 가능한 객체를 구현하려면 Iterator 인터페이스를 구현해야 합니다.

/**
 * Task任务类
 */
class Task
{
    protected $taskId;
    protected $coroutine;
    protected $beforeFirstYield = true;
    protected $sendValue;

    /**
     * Task constructor.
     * @param $taskId
     * @param Generator $coroutine
     */
    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        $this->coroutine = $coroutine;
    }

    /**
     * 获取当前的Task的ID
     * 
     * @return mixed
     */
    public function getTaskId()
    {
        return $this->taskId;
    }

    /**
     * 判断Task执行完毕了没有
     * 
     * @return bool
     */
    public function isFinished()
    {
        return !$this->coroutine->valid();
    }

    /**
     * 设置下次要传给协程的值，比如 $id = (yield $xxxx)，这个值就给了$id了
     * 
     * @param $value
     */
    public function setSendValue($value)
    {
        $this->sendValue = $value;
    }

    /**
     * 运行任务
     * 
     * @return mixed
     */
    public function run()
    {
        // 这里要注意，生成器的开始会reset，所以第一个值要用current获取
        if ($this->beforeFirstYield) {
            $this->beforeFirstYield = false;
            return $this->coroutine->current();
        } else {
            // 我们说过了，用send去调用一个生成器
            $retval = $this->coroutine->send($this->sendValue);
            $this->sendValue = null;
            return $retval;
        }
    }
}

Generator

다음과 같이 말할 수 있습니다. foreach로 탐색할 수 있는 개체의 경우 yield 키워드를 사용하여 이 프로세스를 단순화할 수 있습니다.

생성기는 간단한 객체 반복을 구현하는 더 쉬운 방법을 제공합니다. Iterator 인터페이스를 구현하기 위해 클래스를 정의하는 것과 비교하면 성능 오버헤드와 복잡성이 크게 줄어듭니다.

/**
 * Class Scheduler
 */
Class Scheduler
{
    /**
     * @var SplQueue
     */
    protected $taskQueue;
    /**
     * @var int
     */
    protected $tid = 0;

    /**
     * Scheduler constructor.
     */
    public function __construct()
    {
        /* 原理就是维护了一个队列，
         * 前面说过，从编程角度上看，协程的思想本质上就是控制流的主动让出（yield）和恢复（resume）机制
         * */
        $this->taskQueue = new SplQueue();
    }

    /**
     * 增加一个任务
     *
     * @param Generator $task
     * @return int
     */
    public function addTask(Generator $task)
    {
        $tid = $this->tid;
        $task = new Task($tid, $task);
        $this->taskQueue->enqueue($task);
        $this->tid++;
        return $tid;
    }

    /**
     * 把任务进入队列
     *
     * @param Task $task
     */
    public function schedule(Task $task)
    {
        $this->taskQueue->enqueue($task);
    }

    /**
     * 运行调度器
     */
    public function run()
    {
        while (!$this->taskQueue->isEmpty()) {
            // 任务出队
            $task = $this->taskQueue->dequeue();
            $res = $task->run(); // 运行任务直到 yield

            if (!$task->isFinished()) {
                $this->schedule($task); // 任务如果还没完全执行完毕，入队等下次执行
            }
        }
    }
}

🎜 🎜🎜🎜 함수에 yield를 사용하면 함수처럼 직접 호출할 수 없다는 점을 기억하세요! 🎜🎜🎜그래서 yield는 yield입니다. 다음번에 yield가 코루틴이라고 말하는 사람이 있다면 제가 꼭 xxxx대접해 드리겠습니다. 🎜🎜PHP 코루틴🎜🎜앞서 코루틴을 소개할 때 언급했듯이 코루틴에서는 프로그래머가 직접 스케줄링 메커니즘을 작성해야 합니다. 이 메커니즘을 작성하는 방법을 살펴보겠습니다. 🎜🎜0) 제너레이터의 올바른 사용법🎜🎜제너레이터는 함수처럼 직접 호출할 수 없는데 어떻게 호출할 수 있나요? 🎜

方法如下：

1. foreach他
2. send($value)
3. current / next...

1）Task实现

Task就是一个任务的抽象，刚刚我们说了协程就是用户空间协程，线程可以理解就是跑一个函数。

所以Task的构造函数中就是接收一个闭包函数，我们命名为coroutine。

/**
 * Task任务类
 */
class Task
{
    protected $taskId;
    protected $coroutine;
    protected $beforeFirstYield = true;
    protected $sendValue;

    /**
     * Task constructor.
     * @param $taskId
     * @param Generator $coroutine
     */
    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        $this->coroutine = $coroutine;
    }

    /**
     * 获取当前的Task的ID
     * 
     * @return mixed
     */
    public function getTaskId()
    {
        return $this->taskId;
    }

    /**
     * 判断Task执行完毕了没有
     * 
     * @return bool
     */
    public function isFinished()
    {
        return !$this->coroutine->valid();
    }

    /**
     * 设置下次要传给协程的值，比如 $id = (yield $xxxx)，这个值就给了$id了
     * 
     * @param $value
     */
    public function setSendValue($value)
    {
        $this->sendValue = $value;
    }

    /**
     * 运行任务
     * 
     * @return mixed
     */
    public function run()
    {
        // 这里要注意，生成器的开始会reset，所以第一个值要用current获取
        if ($this->beforeFirstYield) {
            $this->beforeFirstYield = false;
            return $this->coroutine->current();
        } else {
            // 我们说过了，用send去调用一个生成器
            $retval = $this->coroutine->send($this->sendValue);
            $this->sendValue = null;
            return $retval;
        }
    }
}

   

2）Scheduler实现

接下来就是Scheduler这个重点核心部分，他扮演着调度员的角色。

/**
 * Class Scheduler
 */
Class Scheduler
{
    /**
     * @var SplQueue
     */
    protected $taskQueue;
    /**
     * @var int
     */
    protected $tid = 0;

    /**
     * Scheduler constructor.
     */
    public function __construct()
    {
        /* 原理就是维护了一个队列，
         * 前面说过，从编程角度上看，协程的思想本质上就是控制流的主动让出（yield）和恢复（resume）机制
         * */
        $this->taskQueue = new SplQueue();
    }

    /**
     * 增加一个任务
     *
     * @param Generator $task
     * @return int
     */
    public function addTask(Generator $task)
    {
        $tid = $this->tid;
        $task = new Task($tid, $task);
        $this->taskQueue->enqueue($task);
        $this->tid++;
        return $tid;
    }

    /**
     * 把任务进入队列
     *
     * @param Task $task
     */
    public function schedule(Task $task)
    {
        $this->taskQueue->enqueue($task);
    }

    /**
     * 运行调度器
     */
    public function run()
    {
        while (!$this->taskQueue->isEmpty()) {
            // 任务出队
            $task = $this->taskQueue->dequeue();
            $res = $task->run(); // 运行任务直到 yield

            if (!$task->isFinished()) {
                $this->schedule($task); // 任务如果还没完全执行完毕，入队等下次执行
            }
        }
    }
}

   

这样我们基本就实现了一个协程调度器。

你可以使用下面的代码来测试：

<?php
function task1() {
    for ($i = 1; $i <= 10; ++$i) {
        echo "This is task 1 iteration $i.\n";
        yield; // 主动让出CPU的执行权
    }
}
 
function task2() {
    for ($i = 1; $i <= 5; ++$i) {
        echo "This is task 2 iteration $i.\n";
        yield; // 主动让出CPU的执行权
    }
}
 
$scheduler = new Scheduler; // 实例化一个调度器
$scheduler->addTask(task1()); // 添加不同的闭包函数作为任务
$scheduler->addTask(task2());
$scheduler->run();

   

关键说下在哪里能用得到PHP协程。

function task1() {
        /* 这里有一个远程任务，需要耗时10s，可能是一个远程机器抓取分析远程网址的任务，我们只要提交最后去远程机器拿结果就行了 */
        remote_task_commit();
        // 这时候请求发出后，我们不要在这里等，主动让出CPU的执行权给task2运行，他不依赖这个结果
        yield;
        yield (remote_task_receive());
        ...
}
 
function task2() {
    for ($i = 1; $i <= 5; ++$i) {
        echo "This is task 2 iteration $i.\n";
        yield; // 主动让出CPU的执行权
    }
}

这样就提高了程序的执行效率。

关于『系统调用』的实现，鸟哥已经讲得很明白，我这里不再说明。

3）协程堆栈

鸟哥文中还有一个协程堆栈的例子。

我们上面说过了，如果在函数中使用了yield，就不能当做函数使用。

所以你在一个协程函数中嵌套另外一个协程函数：

<?php
function echoTimes($msg, $max) {
    for ($i = 1; $i <= $max; ++$i) {
        echo "$msg iteration $i\n";
        yield;
    }
}
 
function task() {
    echoTimes(&#39;foo&#39;, 10); // print foo ten times
    echo "---\n";
    echoTimes(&#39;bar&#39;, 5); // print bar five times
    yield; // force it to be a coroutine
}
 
$scheduler = new Scheduler;
$scheduler->addTask(task());
$scheduler->run();

   

这里的echoTimes是执行不了的！所以就需要协程堆栈。

不过没关系，我们改一改我们刚刚的代码。

把Task中的初始化方法改下，因为我们在运行一个Task的时候，我们要分析出他包含了哪些子协程，然后将子协程用一个堆栈保存。（C语言学的好的同学自然能理解这里，不理解的同学我建议去了解下进程的内存模型是怎么处理函数调用）

 /**
     * Task constructor.
     * @param $taskId
     * @param Generator $coroutine
     */
    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        // $this->coroutine = $coroutine;
        // 换成这个，实际Task->run的就是stackedCoroutine这个函数，不是$coroutine保存的闭包函数了
        $this->coroutine = stackedCoroutine($coroutine); 
    }

   

当Task->run()的时候，一个循环来分析：

/**
 * @param Generator $gen
 */
function stackedCoroutine(Generator $gen)
{
    $stack = new SplStack;

    // 不断遍历这个传进来的生成器
    for (; ;) {
        // $gen可以理解为指向当前运行的协程闭包函数（生成器）
        $value = $gen->current(); // 获取中断点，也就是yield出来的值

        if ($value instanceof Generator) {
            // 如果是也是一个生成器，这就是子协程了，把当前运行的协程入栈保存
            $stack->push($gen);
            $gen = $value; // 把子协程函数给gen，继续执行，注意接下来就是执行子协程的流程了
            continue;
        }

        // 我们对子协程返回的结果做了封装，下面讲
        $isReturnValue = $value instanceof CoroutineReturnValue; // 子协程返回`$value`需要主协程帮忙处理
        
        if (!$gen->valid() || $isReturnValue) {
            if ($stack->isEmpty()) {
                return;
            }
            // 如果是gen已经执行完毕，或者遇到子协程需要返回值给主协程去处理
            $gen = $stack->pop(); //出栈，得到之前入栈保存的主协程
            $gen->send($isReturnValue ? $value->getValue() : NULL); // 调用主协程处理子协程的输出值
            continue;
        }

        $gen->send(yield $gen->key() => $value); // 继续执行子协程
    }
}

   

然后我们增加echoTime的结束标示：

class CoroutineReturnValue {
    protected $value;
 
    public function __construct($value) {
        $this->value = $value;
    }
     
    // 获取能把子协程的输出值给主协程，作为主协程的send参数
    public function getValue() {
        return $this->value;
    }
}

function retval($value) {
    return new CoroutineReturnValue($value);
}

   

然后修改echoTimes：

function echoTimes($msg, $max) {
    for ($i = 1; $i <= $max; ++$i) {
        echo "$msg iteration $i\n";
        yield;
    }
    yield retval("");  // 增加这个作为结束标示
}

Task变为：

function task1()
{
    yield echoTimes('bar', 5);
}

这样就实现了一个协程堆栈，现在你可以举一反三了。

4）PHP7中yield from关键字

PHP7中增加了yield from，所以我们不需要自己实现携程堆栈，真是太好了。

把Task的构造函数改回去：

    public function __construct($taskId, Generator $coroutine)
    {
        $this->taskId = $taskId;
        $this->coroutine = $coroutine;
        // $this->coroutine = stackedCoroutine($coroutine); //不需要自己实现了，改回之前的
    }

   

echoTimes函数：

function echoTimes($msg, $max) {
    for ($i = 1; $i <= $max; ++$i) {
        echo "$msg iteration $i\n";
        yield;
    }
}

   

task1生成器：

function task1()
{
    yield from echoTimes('bar', 5);
}

   

这样，轻松调用子协程。

总结

这下应该明白怎么实现PHP协程了吧？

End...

推荐教程：《php教程》

위 내용은 PHP7에서 코루틴 구현에 대해 자세히 논의의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!