How to understand php thread coroutine

Understanding of threads and coroutines in php

1. Threads
Threads are also called lightweight Process, which is a basic CPU execution unit and the smallest unit in the program execution process, is composed of thread ID, program counter, register set and stack. The introduction of threads reduces the overhead of concurrent execution of programs and improves the concurrency performance of the operating system. Threads do not have their own system resources.

The advantage of threads over processes is that they are faster. Whether it is creating a new thread or terminating a thread; whether it is switching between threads or sharing data or communication between threads, its speed is faster than that of a process. Big advantage.

The emergence of threads is to reduce the consumption of context switching, improve the concurrency of the system, and break through the defect that one process can only do one thing, making intra-process concurrency possible.

2. Coroutine

Coroutine is a user-mode thread. To understand what a "user-mode thread" is, you must first understand What is "kernel state thread". Kernel state threads are scheduled by the operating system. When switching thread contexts, you must first save the context of the previous thread, and then execute the next thread. When the conditions are met, switch back to the previous thread and restore the context. The same is true for coroutines, except that user-mode threads are not scheduled by the operating system, but by programmers, in user-mode.

yieldThis keyword is used to generate an interrupt and save the current context. For example, if a piece of code in the program accesses a remote server, then the CPU is idle at this time, so use Yield gives up the CPU, and then executes the next piece of code. If the next piece of code still accesses other resources besides the CPU, you can also call yield to give up the CPU. Continue execution, so that you can write asynchronous code in a synchronous way. .

①The emergence of coroutines
Before the emergence of coroutines, multi-tasking concurrency must be achieved. In the era of no OS (operating system), the idea of ​​​​state machines can be used to implement multi-tasking. Disassemble and run multiple tasks in a single-process environment, but this mode requires developers to have a clear understanding of each task, and developers also need to develop task-related functions (such as communication between tasks) by themselves.
Later, OS (operating system) appeared, and we began to use the process and thread functions provided by OS to easily achieve multitasking. In the OS, process context switching is controlled by the OS kernel. But then a problem arose. Frequent process context switching led to a decrease in OS performance (mainly short-term execution of low-consuming task processes).

In order to solve this problem, a new concept began to be proposed, which is to run multiple tasks in the same process or thread. This problem is equivalent to returning to the early multi-tasking implementation in the OS-free era. And now the solution is called coroutines. Its essence is to transfer part of the task switching from the kernel to the application layer.

②Basic tools and basic uses of coroutines in PHP

To implement coroutines, PHP provides two new things: generator and yield keyword.

(1)What is a generator?
The generator inherits and implements the iterator, which is similar to the function definition in the PHP code, but uses the yield keyword internally, such as:

When used, it looks like this:

Okay, what does it mean to use it like this?
(1) First, $my_gen = gen(); this code just instantiates a new generator, the code inside is not executed;
(2) $my_gen->current(); The code executes yield "gen1" in step 2 in the generator. At this time, the code is interrupted, and the string "gen1" is passed into the generator $my_gen, and is used as the return value of the current() function;
If you continue to use the current() method to call here, the result will not change. The return value of $my_gen is still gen1
(3) After send("main send") is executed, the string "main send" is The generator $my_gen is passed in, and the generator is passed to ret as the return value of yield in step 2; through the send() method, the previous context will be found and continues downward.
(4) After the generator step3 is executed, when step4 is encountered, it will interrupt again when it encounters yield.

The above content is for reference only!

Recommended tutorial: PHP video tutorial

The above is the detailed content of How to understand php thread coroutine. For more information, please follow other related articles on the PHP Chinese website!