This article shares with you the content about PHP Synergy, which has certain reference value. I hope it can help friends in need.

Concept

We know that multi-process and multi-thread are effective ways to achieve concurrency. However, the context switching resource overhead of multi-process is too high; the overhead of multi-threading is much smaller, which is also the current mainstream practice, but its control is in the kernel, so the user (programmer) loses control of the code, and the thread Context switching also has a certain overhead. At this time, in order to solve the above problems, the concept of "coroutine" came into being. You can think of coroutines as more lightweight threads. This kind of thread is called "user space thread". Coroutines have the following two characteristics:

1. Collaboration. Because it is a scheduling strategy written by the programmer himself, it switches through collaboration rather than preemption

2. Creation, switching and destruction are completed in user mode

PHP's support for coroutines is based on iteration generator, and adds the function of sending data back to the generator (the caller sends data to the called generator function). This turns the one-way communication from the generator to the caller into a two-way communication between the two.

Iterator

The concept of iterator will not be described in detail here. Let's take a look at an iterator we implemented ourselves.

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() {    // 最后执行，就是执行完下面sleep(2)后再执行。(执行了next本次迭代才算结束)
        $var = next($this->var);
        echo "next: $var\n";
        return $var;
    }

    public function valid() {      // 当valid返回false的时候迭代结束
        $var = $this->current() !== false;
        echo "valid: {$var}\n";
        return $var;
    }
}

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

foreach ($it as $a => $b) { // 进行迭代(每次迭代，会依次执行以下方法: rewind(特别之处见上面解释), valid, current, key, next)
    print "=====\n";
    sleep(2);
}

Output:

rewinding
current: 1  // 因为valid里面调用了current, 这里current出来一次
valid: 1
current: 1
key: 0
=====
next: 2
current: 2
valid: 1
current: 2
key: 1
=====
next: 3
current: 3
valid: 1
current: 3
key: 2
=====
next: 4
current: 4
valid: 1
current: 4
key: 3
=====
next: 
current: 
valid:    // valid返回false，迭代结束

Generator

The method with yeild is a generator (the generator implements the Iterator interface, that is, a generator has the characteristics of an iterator). The implementation of the generator is as follows:

function xrange($start, $end, $step = 1) {
    for ($i = $start; $i <= $end; $i += $step) {
        echo $i . "\n";
        yield;
    }
}

// foreach方式
foreach (xrange(1, 10) as $num) {
    
}

$gene = xrange(1, 10); // gene就是一个生成器对象
// current
$gene->current();  // 打印1
// next
$gene->next();
$gene->current()  // 打印2

Output:

1
2
3
4
5
6
7
8
9
10
1
2

For detailed explanation of each method of the generator, please see the document: http://php.net/manual/zh/class.generator. php

Note:

The generator cannot be called directly like a function. The calling method is as follows:

1. foreach him

2. send ($value)

3. current / next...

yield

yield’s syntax is very flexible. Let’s use the following example, let Everyone can understand the use of yield syntax.

Use Case 1: Yield cpu execution rights

function task1 () {
for ($i = 1; $i <= 10; ++$i) {
        echo "This is task 1 iteration $i.\n";
        yield;// 遇到yield就会主动让出CPU的执行权;
    }
}
$a = task1(); 
$a->current(); // 执行第一次迭代
$a->send(1);  // 唤醒当时让出CPU执行权的yield

Output:

This is task 1 iteration 1.
This is task 1 iteration 2.

Use Case 2: Return of yield

// yield返回
function task2 () {
    for ($i = 1; $i <= 10; ++$i) {
            echo "This is task 2 iteration $i.\n";
            yield "lm$i";  // 遇到yield就会主动让出CPU的执行权,for暂停执行, 然后返回"lm"。放在yield后面的值就是返回值
        }
}

$a = task2(); 
$res = $a->current();  // 第一次迭代, 遇到yield返回
var_dump($res);  
$res = $a->send(1);  // 唤醒yield, for继续执行，遇到yield返回。
var_dump($res);

Output:

This is task 2 iteration 1.
string(3) "lm1"
This is task 2 iteration 2.
string(3) "lm2"

Use case 3: yield receives value

function task3 () {
    for ($i = 1; $i <= 10; ++$i) {
            echo "This is task 3 iteration $i.\n";
            $getValue = yield;// 遇到yield就会主动让出CPU的执行权;send后，将send值赋值给getValue
            echo $getValue . " ";
        }
}
$a = task3(); 
$a->current();
$a->send("aa");  // 唤醒yield，并将"aa"值赋值给$getValue变量

Output:

This is task 3 iteration 1.
aa This is task 3 iteration 2.

Use case 4: yeild reception and return are written together

function task4 () {
    for ($i = 1; $i <= 10; ++$i) {
        echo "This is task 4 iteration $i.\n";
        $ret = yield "lm$i";  // yield, 然后返回lm$i； 当send时，将send过来的值赋值给$ret；
        echo $ret;
    }
}
$a = task4(); 
var_dump($a->current());     // 返回lm1
var_dump($a->send("hhh "));  // 先唤醒yield, 将"hhh "赋值给$ret，再返回lm2
var_dump($a->send("www "));  // 先唤醒yield, 将"www "赋值给$ret，再返回lm3

Output:

This is task 4 iteration 1.
string(3) "lm1"hhh 
This is task 4 iteration 2.
 string(3) "lm2"www 
 This is task 4 iteration 3.
 string(3) "lm3"

Related recommendations:

How to use abstract classes and interfaces in PHP (code)

Code implementation of PHP paging and regular verification

The above is the detailed content of Detailed explanation of PHP coroutine content. For more information, please follow other related articles on the PHP Chinese website!