PHP Swoole implementiert geplante Aufgaben auf Millisekundenebene

Wenn während der Projektentwicklung Geschäftsanforderungen für geplante Aufgaben vorliegen, verwenden wir zur Lösung das Crontab von Linux, dessen Mindestgranularität jedoch auf der Minutenebene liegt. Selbst auf Millisekundenebene kann Crontab dies nicht erfüllen. Glücklicherweise bietet Swoole einen leistungsstarken Millisekunden-Timer.

Empfohlenes Lernen: Swoole-Tutorial

Beispiele für Anwendungsszenarien

Wir könnten auf ein solches Szenario stoßen:

● Szenario 1: Ermitteln Sie die lokale Speichernutzung alle 30 Sekunden

● Szenario 2: Führen Sie die Berichtsversandaufgabe nach 2 Minuten aus

● Szenario 3: Jeden Tag um 14 Uhr Fordern Sie die Schnittstelle eines Drittanbieters regelmäßig an. Wenn die Schnittstelle aus irgendeinem Grund nicht antwortet oder keine Daten zurückgegeben werden, versuchen Sie weiterhin, die Schnittstelle anzufordern schlägt nach 5 Versuchen fehl, stoppen Sie die Aufgabe

Wir können alle oben genannten drei Szenarien in die Kategorie der geplanten Aufgaben einordnen.

Swoole Millisekunden-Timer

Swoole bietet eine asynchrone Millisekunden-Timer-Funktion:

swoole_timer_tick(int $msec, callable $callback): Stellen Sie einen Intervalluhr-Timer ein, alle $ms führt $ aus Rückruf einmal pro Millisekunde, ähnlich wie setInterval() in Javascript.

swoole_timer_after(int $after_time_ms, mixed $callback_function): Führen Sie $after_time_ms nach der angegebenen Zeit $callback_function aus, ähnlich wie bei Javascript setTimeout().

swoole_timer_clear(int $timer_id): Löschen Sie den Timer mit der angegebenen ID, ähnlich wie bei Javascript clearInterval().

Lösung

Für Szenario 1 wird es häufig in der Systemerkennungsstatistik verwendet. Die Echtzeitanforderungen sind relativ hoch, aber die Häufigkeit kann gut kontrolliert werden Wird hauptsächlich für die Hintergrundserverleistung verwendet. Durch die Überwachung können visuelle Diagramme erstellt werden. Die Speichernutzung kann alle 30 Sekunden oder alle 10 Sekunden ermittelt werden, die Mindestgranularität von crontab kann jedoch nur auf 1 Minute festgelegt werden.

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

Wenn Sie für Szenario zwei eine bestimmte Aufgabe direkt nach xx Zeit definieren, scheint Crontab schwieriger zu sein, aber die Verwendung von swooles swoole_timer_after kann Folgendes erreichen:

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

Für Szenario drei wird es verwendet, um versuchte Anfragen zu stellen. Wenn die Anfrage erfolgreich ist, wird sie gestoppt. Es kann auch mit Crontab gelöst werden, aber es ist ziemlich albern. Wenn Sie beispielsweise alle 5 Minuten eine Anfrage stellen, wird diese unabhängig von Erfolg oder Misserfolg ausgeführt. Die Verwendung eines Swoole-Timers ist viel intelligenter.

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";
     }
 });

Beispielcode

Erstellen Sie eine neue Datei srcAppTask.php:

<?php 
namespace Helloweba\Swoole;

use swoole_server;

/**
* 任务调度
*/
class Task
{
    protected $serv;
    protected $host = &#39;127.0.0.1&#39;;
    protected $port = 9506;
    // 进程名称
    protected $taskName = &#39;swooleTask&#39;;
    // PID路径
    protected $pidPath = &#39;/run/swooletask.pid&#39;;
    // 设置运行时参数
    protected $options = [
        &#39;worker_num&#39; => 4, //worker进程数,一般设置为CPU数的1-4倍  
        &#39;daemonize&#39; => true, //启用守护进程
        &#39;log_file&#39; => &#39;/data/log/swoole-task.log&#39;, //指定swoole错误日志文件
        &#39;log_level&#39; => 0, //日志级别 范围是0-5，0-DEBUG，1-TRACE，2-INFO，3-NOTICE，4-WARNING，5-ERROR
        &#39;dispatch_mode&#39; => 1, //数据包分发策略,1-轮询模式
        &#39;task_worker_num&#39; => 4, //task进程的数量
        &#39;task_ipc_mode&#39; => 3, //使用消息队列通信，并设置为争抢模式
    ];

    public function __construct($options = [])
    {
        date_default_timezone_set(&#39;PRC&#39;); 
        // 构建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(&#39;Start&#39;, [$this, &#39;onStart&#39;]);
        $this->serv->on(&#39;Connect&#39;, [$this, &#39;onConnect&#39;]);
        $this->serv->on(&#39;Receive&#39;, [$this, &#39;onReceive&#39;]);
        $this->serv->on(&#39;Task&#39;, [$this, &#39;onTask&#39;]);  
        $this->serv->on(&#39;Finish&#39;, [$this, &#39;onFinish&#39;]);
        $this->serv->on(&#39;Close&#39;, [$this, &#39;onClose&#39;]);
    }

    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(&#39;接收客户端参数：&#39;.$fd .&#39;-&#39;.$data);
        $res[&#39;result&#39;] = &#39;success&#39;;
        $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(&#39;Y-m-d H:i:s&#39;) . &#39;当前内存使用率：&#39;.$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;
    }
}

Nehmen wir mal Szenario eins Aktivieren Sie beispielsweise geplante Aufgaben in onTask und berechnen Sie alle 30 Sekunden die Speichernutzung. In tatsächlichen Anwendungen kann der berechnete Speicher zeitbasiert in eine Datenbank und einen anderen Speicher geschrieben und dann zum Rendern statistischer Diagramme entsprechend den Front-End-Anforderungen verwendet werden, z. B.:

und dann der Servercode publictaskServer.php:

<?php 
require dirname(__DIR__) . &#39;/vendor/autoload.php&#39;;
use Helloweba\Swoole\Task;
$opt = [
    &#39;daemonize&#39; => false
];
$ser = new Task($opt);
$ser->start();

Clientcode publictaskClient.php:

<?php 
class Client
{
    private $client;
    public function __construct() {
        $this->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();

Verifizierung Wirkung

1. Starten Sie den Server:

php taskServer.php

2. Öffnen Sie ein weiteres Befehlszeilenfenster und führen Sie

[root@localhost public]# php taskClient.php

Bitte geben Sie die Nachricht ein: hallo

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

3. Der Server gibt Folgendes zurück:

Wenn Sie Zurück zum Obigen Das Ergebnis im Bild zeigt, dass die geplante Aufgabe normal ausgeführt wird, und wir werden feststellen, dass alle 30 Sekunden eine Meldung ausgegeben wird.

Das obige ist der detaillierte Inhalt vonPHP Swoole implementiert geplante Aufgaben auf Millisekundenebene. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!