What is the implementation principle of swoole coroutine?

In swoole, the Swoole server receives data and triggers the onReceive callback in the worker process to generate a coroutine. Swoole creates a corresponding coroutine for each request. Sub-coroutines can also be created in the coroutine. The coroutine is implemented at the bottom It is single-threaded, so only one coroutine is working at the same time.

The operating environment of this tutorial: Windows10 system, Swoole4 version, DELL G3 computer

What is the implementation principle of swoole coroutine

What is a process?

The process is the startup instance of the application. Independent file resources, data resources, and memory space.

What is a thread?

Threads belong to processes and are the executors of programs. A process contains at least one main thread and can also have more child threads. Threads have two scheduling strategies, one is: time-sharing scheduling, and the other is: preemptive scheduling.

What is a coroutine?

Coroutines are lightweight threads, coroutines also belong to threads, and coroutines are executed in threads. The scheduling of coroutines is manually switched by the user, so it is also called user space thread. The creation, switching, suspension, and destruction of coroutines are all memory operations, and the consumption is very low. The scheduling strategy of coroutines is: collaborative scheduling.

The principle of Swoole coroutine

Swoole4 Since it is single-threaded and multi-process, there will only be one coroutine running in the same process at the same time.

Swoole server receives data and triggers the onReceive callback in the worker process, generating a Ctrip. Swoole creates a corresponding Ctrip for each request. Sub-coroutines can also be created in coroutines.

The underlying implementation of the coroutine is single-threaded, so there is only one coroutine working at the same time, and the execution of the coroutine is serial.

So when multi-tasking and multi-coroutine are executed, when one coroutine is running, other coroutines will stop working. The current coroutine will hang when performing blocking IO operations, and the underlying scheduler will enter the event loop. When an IO completion event occurs, the underlying scheduler resumes the execution of the coroutine corresponding to the event. . Therefore, coroutines do not have IO time consumption and are very suitable for high-concurrency IO scenarios. (As shown below)

Swoole’s coroutine execution process

• The coroutine has no IO and is waiting for normal execution PHP code will not cause execution flow switching

• When the coroutine encounters IO, it will wait and immediately switch control. After the IO is completed, the execution flow will be switched back to the original coroutine. Click

• Coroutines and parallel coroutines are executed in sequence, the same logic as the previous one

• Coroutine nested execution process is entered layer by layer from outside to inside until IO occurs, and then switches to the outer coroutine. The parent coroutine will not wait for the end of the child coroutine

The execution sequence of the coroutine

Let’s take a look at a basic example first:

go(function () { echo "hello go1 \n";});echo "hello main \n";go(function () { echo "hello go2 \n";});

go() is the abbreviation of \Co::create(), which is used to create a coroutine and accept callback as a parameter. The code in callback will be created here Executed in the coroutine.

Remarks: \Swoole\Coroutine can be abbreviated as \Co

The execution result of the above code:

root@b98940b00a9b /v/w/c/p/swoole# php co.phphello go1 hello main hello go2

The execution result is the same as when we usually write code There seems to be no difference in the order. Actual execution process:

• Run this code, the system starts a new process

• encounters go() , a coroutine is generated in the current process, heelo go1 is output in the coroutine, the coroutine exits

• The process continues to execute the code, and outputs hello main

• Generate a coroutine, output heelo go2 in the coroutine, and exit the coroutine

Run this code, the system starts a new process. If you don’t understand this sentence, you You can use the following code:

// co.php
        

         Copy after login
        
       

Execute and use ps aux to view the processes in the system:

root@b98940b00a9b /v/w/c/p/swoole# php co.php &⏎ root@b98940b00a9b /v/w/c/p/swoole# ps auxPID USER TIME COMMAND 1 root 0:00 php -a 10 root 0:00 sh 19 root 0:01 fish 749 root 0:00 php co.php 760 root 0:00 ps aux

Let’s make a slight change and experience the scheduling of coroutines:

use Co;go(function () { Co::sleep(1); // 只新增了一行代码 echo "hello go1 \n";});echo "hello main \n";go(function () { echo "hello go2 \n";}); \Co::sleep() 函数功能和 sleep() 差不多, 但是它模拟的是 IO等待(IO后面会细讲). 执行的结果如下: root@b98940b00a9b /v/w/c/p/swoole# php co.phphello main hello go2 hello go1

Why is it not executed sequentially? Actual execution process:

• Run this code, the system starts a new process

• encounters go() , a coroutine is generated in the current process

• The coroutine encounters IO blocking (here is the IO waiting simulated by Co::sleep()), the coroutine gives up control and enters Coroutine scheduling queue

• The process continues to execute downwards and outputs hello main

• Execute the next coroutine and output hello go2

• The previous coroutine is ready, continue execution, and output hello go1

At this point, you can already see the relationship between the coroutine and the process in swoole, and For coroutine scheduling, let’s change the program just now:

go(function () { Co::sleep(1); echo "hello go1 \n";});echo "hello main \n";go(function () { Co::sleep(1); echo "hello go2 \n";});

I think you already know what the output looks like:

root@b98940b00a9b /v/w/c/p/swoole# php co.phphello main hello go1 hello go2

Recommended learning:swoole tutorial

The above is the detailed content of What is the implementation principle of swoole coroutine?. For more information, please follow other related articles on the PHP Chinese website!