What are the application scenarios for using swoole in PHP?

php The application scenarios for using swoole are: 1. Collect positioning data in real time and output it in real time. All positioning devices need to be received in real time and the real-time track records are displayed on the map; 2. Only positioning devices are collected. To store, the data uploaded by all positioning devices needs to be stored in the database.

php The application scenarios for using swoole are:

Scenario 1 - Real-time collection of positioning data and real-time output (Example Didi driver’s driving trajectory)

Instructions:

It is necessary to receive all positioning devices in real time and display the real-time trajectory records on the map

Note:

The first point:

Web1 server is connected to users 1, 2, 3. When web1 broadcasts information, it can only broadcast users 1, 2, 3. Users 4, 5, and 6 who cannot broadcast web2 connections. Assume that the scene is chatting. User 1 sends a message. Only users of the web1 server can see it. All users of web2 cannot receive it.

Second point: Message Frequency control, for example: 100 devices, 100 users, 100 devices upload one piece of data per second, which needs to be broadcast to each user in real time, that is, 100*100 = 1W times per second, so the data per second can be summarized and broadcast to All users and other methods

Scenario 2 - Only collect positioning devices into the database

Instructions: All positioning devices need to be uploaded The data is stored in the database, with 7 devices and one piece of data per second. I personally use swoole's task function (deliver an asynchronous task to the task_worker pool. This function is non-blocking and the number of worker processes can also be configured) and then calls the interface to store it in the database.

Server memory alarm problem

Cause: swoole_server->task Function

Officially introduces that the bottom layer of task uses Unix Socket pipe communication, which is full memory Yes, there is no IO consumption. The read and write performance of a single process can reach 1 million/s. Different processes use different pipelines to communicate, which can maximize the use of multiple cores.

But if the task is to call the program interface, due to network delay, when the added tasks are larger than the consumed tasks, the memory usage will continue to increase, causing the server's memory to be full.

Solution: Control the frequency of messages entering the task. You can define this time and whether it can be delayed according to your own business scenario, summarize all the data within 1 second and then call the program interface (I personally use redis when summarizing ), it is best to store it directly in the database without calling the interface

Simple code snippet

function __construct($config) 
{
    $this->config = $config;
    $this->serv = new Swoole\Server($config['server']['host'], $config['server']['port']);
    // 连接redis
    $this->redis = new Predis\Client($config['redis']);
    $this->storage = new Storage($this->config);
    $this->serv->set([
        'worker_num'      => $this->config['server']['workerNum'],   //工作进程数量
        'daemonize'       => $this->config['server']['daemonize'], //是否作为守护进程
        'task_worker_num' => $this->config['server']['taskWorkerNum'],
    ]);
    $this->serv->on('connect', function ($serv, $fd){
        $this->onConnect($fd, $serv);
    });
    
    $this->serv->on('receive', function ($serv, $fd, $from_id, $data)  {
        $this->onReceive($fd, $serv, $data);
    });
    $this->serv->on('Close', function($server, $fd) {
        $this->onClose($fd, $server);
        
    });
    $this->serv->on('Task', function($server, $task_id, $from_id, $data) {
        $this->onTask($server, $task_id, $from_id, $data);
        
    });
    $this->serv->on('Finish', function($server, $task_id, $data) {
        $this->onFinish($server, $task_id, $data);
        
    });
    $this->serv->start();
}
public function onTask($serv, $task_id, $from_id, $data){
    // insert 方法是通过接口入库
    $this->storage->insert($data);
}
public function onReceive($fd, $serv, $data)
{
    $this->storage->writeLog('message:'.$data);
    $data = $this->formatData($data, $fd);
    $serv->task($data);
}
public function onClose($fd, $serv) 
{
    // writeLog 方法是写入log
    $this->storage->writeLog('close fd:'.$fd);
}
public function onFinish($serv, $task_id, $data)
{
    return '';
}

Related learning recommendations:PHP programming from entry to proficiency

The above is the detailed content of What are the application scenarios for using swoole in PHP?. For more information, please follow other related articles on the PHP Chinese website!