The difference between swoole coroutine and asynchronous

Starting from version 4.0, Swoole provides complete coroutine (Coroutine) channel (Channel) features, bringing a new CSP programming model.

The application layer can use fully synchronous programming, and the bottom layer automatically implements asynchronous IO. (Recommended learning: swoole video tutorial)

go(function () {
    $redis = new Swoole\Coroutine\Redis();
    $redis->connect('127.0.0.1', 6379);
    $val = $redis->get('key');
});

4.0.0 or higher version only supports PHP7

It has been removed since version 4.0.1 --enable-coroutine compilation option, changed to dynamic configuration

Coroutine can be understood as a pure user-mode thread, which switches through cooperation rather than preemption. Compared with processes or threads, all operations of coroutines can be completed in user mode, and creation and switching costs are lower.

Swoole can create a corresponding coroutine for each request and reasonably schedule the coroutine according to the IO status. This will bring the following advantages:

Development Users can use synchronous code writing to achieve the effect and performance of asynchronous IO without any awareness, avoiding the discrete code logic caused by traditional asynchronous callbacks and being trapped in multi-layer callbacks, resulting in unmaintainable code

At the same time, due to the The bottom layer encapsulates coroutines, so compared to 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 have an in-depth understanding of the semantics of yield and call each level. All are modified to yield, which greatly improves development efficiency

and can meet the needs of most developers. For private protocols, developers can use the TCP or UDP interface of the coroutine for convenient encapsulation.

If you need to perform a time-consuming operation in the Server program, such as sending a broadcast from a chat server or sending an email from a Web server. If you directly execute these functions, the current process will be blocked, causing the server to respond slowly.

Swoole provides the function of asynchronous task processing, which can deliver an asynchronous task to the TaskWorker process pool for execution without affecting the processing speed of the current request.

Program code

Based on the first TCP server, only two event callback functions, onTask and onFinish, need to be added. In addition, you need to set the number of task processes. You can configure an appropriate number of task processes according to the time consumption and task volume of the task.

$serv = new swoole_server("127.0.0.1", 9501);

//设置异步任务的工作进程数量
$serv->set(array('task_worker_num' => 4));

$serv->on('receive', function($serv, $fd, $from_id, $data) {
    //投递异步任务
    $task_id = $serv->task($data);
    echo "Dispath AsyncTask: id=$task_id\n";
});

//处理异步任务
$serv->on('task', function ($serv, $task_id, $from_id, $data) {
    echo "New AsyncTask[id=$task_id]".PHP_EOL;
    //返回任务执行的结果
    $serv->finish("$data -> OK");
});

//处理异步任务的结果
$serv->on('finish', function ($serv, $task_id, $data) {
    echo "AsyncTask[$task_id] Finish: $data".PHP_EOL;
});

$serv->start();

After calling $serv->task(), the program returns immediately and continues to execute the code. The onTask callback function is executed asynchronously in the Task process pool. After the execution is completed, call $serv->finish() to return the result.

The above is the detailed content of The difference between swoole coroutine and asynchronous. For more information, please follow other related articles on the PHP Chinese website!