php Swoole implements millisecond-level scheduled tasks-Swoole-php.cn

php Swoole implements millisecond-level scheduled tasks

藏色散人

Release： 2020-01-25 19:14:16

forward

3968 people have browsed it

php Swoole implements millisecond-level scheduled tasks

During project development, if there are business requirements for scheduled tasks, we will use Linux's crontab to solve it, but its minimum granularity is minute level. If the required granularity is second level, Even at the millisecond level, crontab cannot satisfy it. Fortunately, swoole provides a powerful millisecond timer.

Recommended learning: swoole tutorial

Application scenario examples

We may encounter such a scenario:

● Scenario 1: Obtain the local memory usage every 30 seconds

● Scenario 2: Execute the report sending task after 2 minutes

● Scenario 3: Every day at 2 o'clock in the morning Request the third-party interface regularly. If the interface returns data, the task will be stopped. If the interface does not respond for some reason or no data is returned, continue to try to request the interface after 5 minutes. If it still fails after trying 5 times, stop the task

We can all summarize the above three scenarios into the category of scheduled tasks.

Swoole millisecond timer

Swoole provides an asynchronous millisecond timer function:

swoole_timer_tick(int $msec, callable $callback) : Set an interval clock timer and execute $callback every $msec milliseconds, similar to setInterval() in javascript.

swoole_timer_after(int $after_time_ms, mixed $callback_function): Execute $callback_function after the specified time $after_time_ms, similar to javascript setTimeout().

swoole_timer_clear(int $timer_id): Delete the timer with the specified id, similar to javascript's clearInterval().

Solution

For scenario one, it is often used in system detection statistics. The real-time requirements are relatively high, but the frequency can be controlled well. It is mostly used for background server performance. Monitoring can generate visual charts. The memory usage can be obtained once every 30 seconds, or every 10 seconds, but the minimum granularity of crontab can only be set to 1 minute.

 swoole_timer_tick(30000, function($timer) use ($task_id) { // 启用定时器，每30秒执行一次
     $memPercent = $this->getMemoryUsage(); //计算内存使用率
     echo date('Y-m-d H:i:s') . '当前内存使用率：'.$memPercent."\n";
 });

Copy after login

For scenario two, if you directly define a certain task after xx time, it seems that crontab is more difficult, but using swoole's swoole_timer_after can achieve:

 swoole_timer_after(120000, function() use ($str) { //2分钟后执行
     $this->sendReport(); //发送报表
     echo "send report, $str\n";
 });

Copy after login

For scenario three, it is used to make attempted requests. Continue after the request fails, and stop the request if it succeeds. It can also be solved using crontab, but it is rather silly. For example, if you set a request every 5 minutes, it will be executed regardless of success or failure. Using a swoole timer is much smarter.

swoole_timer_tick(5*60*1000, function($timer) use ($url) { // 启用定时器，每5分钟执行一次
      $rs = $this->postUrl($url);
  
      if ($rs) {
          //业务代码...
          swoole_timer_clear($timer); // 停止定时器
          echo date('Y-m-d H:i:s'). "请求接口任务执行成功\n";
      } else {
          echo date('Y-m-d H:i:s'). "请求接口失败，5分钟后再次尝试\n";
     }
 });

Copy after login

Sample code

New file\src\App\Task.php:

 4, //worker进程数,一般设置为CPU数的1-4倍  
        'daemonize' => true, //启用守护进程
        'log_file' => '/data/log/swoole-task.log', //指定swoole错误日志文件
        'log_level' => 0, //日志级别 范围是0-5，0-DEBUG，1-TRACE，2-INFO，3-NOTICE，4-WARNING，5-ERROR
        'dispatch_mode' => 1, //数据包分发策略,1-轮询模式
        'task_worker_num' => 4, //task进程的数量
        'task_ipc_mode' => 3, //使用消息队列通信，并设置为争抢模式
    ];

    public function __construct($options = [])
    {
        date_default_timezone_set('PRC'); 
        // 构建Server对象，监听127.0.0.1:9506端口
        $this->serv = new swoole_server($this->host, $this->port);

        if (!empty($options)) {
            $this->options = array_merge($this->options, $options);
        }
        $this->serv->set($this->options);

        // 注册事件
        $this->serv->on('Start', [$this, 'onStart']);
        $this->serv->on('Connect', [$this, 'onConnect']);
        $this->serv->on('Receive', [$this, 'onReceive']);
        $this->serv->on('Task', [$this, 'onTask']);  
        $this->serv->on('Finish', [$this, 'onFinish']);
        $this->serv->on('Close', [$this, 'onClose']);
    }

    public function start()
    {
        // Run worker
        $this->serv->start();
    }

    public function onStart($serv)
    {
        // 设置进程名
        cli_set_process_title($this->taskName);
        //记录进程id,脚本实现自动重启
        $pid = "{$serv->master_pid}\n{$serv->manager_pid}";
        file_put_contents($this->pidPath, $pid);
    }

    //监听连接进入事件
    public function onConnect($serv, $fd, $from_id)
    {
        $serv->send( $fd, "Hello {$fd}!" );
    }

    // 监听数据接收事件
    public function onReceive(swoole_server $serv, $fd, $from_id, $data)
    {
        echo "Get Message From Client {$fd}:{$data}\n";
        //$this->writeLog('接收客户端参数：'.$fd .'-'.$data);
        $res['result'] = 'success';
        $serv->send($fd, json_encode($res)); // 同步返回消息给客户端
        $serv->task($data);  // 执行异步任务
    }

    /**
    * @param $serv swoole_server swoole_server对象
    * @param $task_id int 任务id
    * @param $from_id int 投递任务的worker_id
    * @param $data string 投递的数据
    */
    public function onTask(swoole_server $serv, $task_id, $from_id, $data)
    {
        swoole_timer_tick(30000, function($timer) use ($task_id) { // 启用定时器，每30秒执行一次
            $memPercent = $this->getMemoryUsage();
            echo date('Y-m-d H:i:s') . '当前内存使用率：'.$memPercent."\n";
        });
    }


    /**
    * @param $serv swoole_server swoole_server对象
    * @param $task_id int 任务id
    * @param $data string 任务返回的数据
    */
    public function onFinish(swoole_server $serv, $task_id, $data)
    {
        //
    }


    // 监听连接关闭事件
    public function onClose($serv, $fd, $from_id) {
        echo "Client {$fd} close connection\n";
    }

    public function stop()
    {
        $this->serv->stop();
    }

    private function getMemoryUsage()
    {
        // MEMORY
        if (false === ($str = @file("/proc/meminfo"))) return false;
        $str = implode("", $str);
        preg_match_all("/MemTotal\s{0,}\:+\s{0,}([\d\.]+).+?MemFree\s{0,}\:+\s{0,}([\d\.]+).+?Cached\s{0,}\:+\s{0,}([\d\.]+).+?SwapTotal\s{0,}\:+\s{0,}([\d\.]+).+?SwapFree\s{0,}\:+\s{0,}([\d\.]+)/s", $str, $buf);
        //preg_match_all("/Buffers\s{0,}\:+\s{0,}([\d\.]+)/s", $str, $buffers);

        $memTotal = round($buf[1][0]/1024, 2);
        $memFree = round($buf[2][0]/1024, 2);
        $memUsed = $memTotal - $memFree;
        $memPercent = (floatval($memTotal)!=0) ? round($memUsed/$memTotal*100,2):0;

        return $memPercent;
    }
}

Copy after login

We take scenario 1 as an example, enable scheduled tasks in onTask, and calculate memory usage every 30 seconds. In actual applications, the calculated memory can be written into a database or other storage based on time, and then used to render a statistical chart according to the front-end requirements, such as:

php Swoole implements millisecond-level scheduled tasks

Then the server side Code public\taskServer.php:

 false
];
$ser = new Task($opt);
$ser->start();

Copy after login

Client code public\taskClient.php:

client = new swoole_client(SWOOLE_SOCK_TCP);
    }
    public function connect() {
        if( !$this->client->connect("127.0.0.1", 9506 , 1) ) {
            echo "Error: {$this->client->errMsg}[{$this->client->errCode}]\n";
        }
        fwrite(STDOUT, "请输入消息 Please input msg：");
        $msg = trim(fgets(STDIN));
        $this->client->send( $msg );
        $message = $this->client->recv();
        echo "Get Message From Server:{$message}\n";
    }
}
$client = new Client();
$client->connect();

Copy after login

Verification effect

1. Start the server:

php taskServer.php

2. Client input:

Open another command line window and execute

[root@localhost public]# php taskClient.php

Copy after login

Please input msg: hello

Get Message From Server:{"result":"success"}
[root@localhost public]#

Copy after login

3. The server returns:

php Swoole implements millisecond-level scheduled tasks

If the result in the above picture is returned, the scheduled task is running normally, and we will find that a message will be output every 30 seconds.

The above is the detailed content of php Swoole implements millisecond-level scheduled tasks. For more information, please follow other related articles on the PHP Chinese website!