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.
My official penguin group
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 to generate 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
go() is the abbreviation of \Co::create(), used to create a coroutine, accepting callback as a parameter, in callback The code will be executed in this newly created coroutine.
Remarks: \Swoole\Coroutine can be abbreviated to \Co
The above code Execution result:
root@b98940b00a9b /v/w/c/p/swoole# php co.phphello go1
hello main
hello go2
Copy after login
The execution result seems to be no different from the order in which we usually write code. 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, and the coroutine exits
The process continues to execute the code, and outputs hello main
generates a coroutine, and outputs # in the coroutine ##heelo go2, coroutine exits
Run this code, the system starts a new process. If you don’t understand this sentence, you can use the following code:
// co.php<?phpsleep (100);
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
⏎
Copy after login
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";});
Copy after login
\Co::sleep() The function function is similar to sleep(), but it simulates IO waiting (IO will be discussed in detail later). The execution result is as follows:
root@b98940b00a9b /v/w/c/p/swoole# php co.phphello main
hello go2
hello go1
Copy after login
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
Co::sleep() simulated IO waiting), the coroutine gives up control and enters the coroutine The process scheduling queue
process continues to execute downwards, outputs
hello main
executes the next coroutine, and outputs
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, as well as the scheduling of the coroutine , let’s change the program just now:
The above is the detailed content of When asked three times by the swoole coroutine, I almost cried!. For more information, please follow other related articles on the PHP Chinese website!
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
