Are coroutines used in swoole?

Coroutines are used in swoole. Coroutines are mainly used to convert competitive resources in threads into collaborative operations. Coroutines can be simply understood as threads, which are more lightweight threads, but coroutines cannot be used. Multi-core CPU is suitable for processing IO-intensive tasks, high-concurrency services, etc.

The operating environment of this tutorial: Windows 10 system, Swoole 4 version, DELL G3 computer

Is coroutine used in swoole?

Coroutines are used in swoole

What are coroutines

Coroutines can be simply understood as threads, but this thread is in user mode It does not require the participation of the operating system, and the cost of creation, destruction and switching is very low. Unlike threads, coroutines cannot take advantage of multi-core CPUs. If you want to take advantage of multi-core CPUs, you need to rely on Swoole's multi-process model.

Coroutine Features

Developers can use synchronous code writing to achieve the effect and performance of asynchronous IO without any awareness, avoiding the problems caused by traditional asynchronous callbacks Discrete code logic and being trapped in multiple layers of callbacks make the code unmaintainable.

At the same time, because the bottom layer encapsulates the coroutine, compared with the traditional PHP layer coroutine framework, developers do not need to use the yield keyword to identify a coroutine IO operation, so there is no need to go into the semantics of yield in depth. Understanding and calling each level are modified to yield, which greatly improves development efficiency.

Coroutines are suitable for IO-intensive applications because coroutines are automatically scheduled when IO is blocked, reducing the time loss caused by IO blocking.

Sleep 10,000 times, read, write, check and delete files 10,000 times, use PDO and MySQLi to communicate with the database 10,000 times, create a TCP server and multiple clients to communicate with each other 10,000 times, From creating a UDP server and multiple clients to communicating with each other 10,000 times... everything is done perfectly in one process and within one second!

Applicable scenarios

High concurrency services, such as flash sale system, high-performance API interface, RPC server, connection pool, IM chat, game server, Internet of Things, message server wait.

Example 1:

Users can create a coroutine through the go function to achieve concurrent execution, as shown in the following code:

go(function () {
    echo "one" . PHP_EOL;
});
go(function () {
    echo "two" . PHP_EOL;
});
go(function () {
    echo "three" . PHP_EOL;
});

Whenever a go appears, the bottom layer will automatically create a coroutine. After the coroutine outputs the content, it will automatically exit

Example 2:

Concurrency can be achieved through the coroutine To execute client requests, use the scheduling when IO is blocked caused by coroutine scheduling to achieve high-performance services. The following is the concurrent execution of requests through the defer mechanism:

go(function () {
    // 协程 MySQL 客户端
    $mysql = new Swoole\Coroutine\MySQL();
    $mysql->connect([
        'host' => '172.17.0.1',
        'user' => 'root',
        'password' => 'root',
        'database' => 'swoole',
    ]);
    $mysql->setDefer();
    $mysql->query('select sleep(2);');
    
     print_r("time1: " . time() . PHP_EOL);
    
    // 协程 Redis 客户端
    $redis = new Swoole\Coroutine\Redis();
    $redis->connect('172.17.0.1', 6379);
    $redis->setDefer();
    $redis->set('name', '张三');
    $redis->recv();
    
    print_r("time2: " . time() . PHP_EOL);
    $redis->setDefer();
    $redis->get('name');
    $res1 = $mysql->recv();
    $res2 = $redis->recv();
    print_r(['result1: ' => $res1[0]['sleep'], 'result2: ' => $res2, 'time3: ' => time()]);
});

Taking the above code as an example, you can Simply understand that in defer mode, the request responses of multiple clients are concurrent. After setting setDefer(true), a request is initiated through the Redis or MySQL client. It will no longer wait for the server to return the result, but will return immediately after sending the request. true. After this, you can continue to initiate other Redis and MySQL requests, and finally use the recv() method to receive the response content.

Notes

If the same coroutine client is shared between multiple coroutines, the synchronization blocking procedures are different, and the coroutines process requests concurrently, so the same There may be many requests being processed in parallel. Once the client connection is shared, data confusion will occur between different coroutines.

Coroutines synchronize the original asynchronous logic, but the switching of coroutines occurs implicitly, so the consistency of global variables and static variables cannot be guaranteed before and after coroutine switching.

Recommended learning: swoole tutorial

The above is the detailed content of Are coroutines used in swoole?. For more information, please follow other related articles on the PHP Chinese website!