Présentation du processus dans Swoole

Recommandé (gratuit) : swoole

Initialement prévu pour développer le module Process dans le framework swoft , vous devez donc avoir une compréhension plus approfondie du module Processus de swoole. Cependant, selon le processus de pratique du wiki officiel de swoole, il y a toujours des parties qui ne sont pas comprises, même si j'en ai fait de la programmation multi-processus. fois auparavant, mais lorsque vous avez vraiment besoin de développer un cadre, vous constaterez que les connaissances que vous avez acquises auparavant ne sont pas suffisamment complètes pour guider la conception globale. Heureusement, vous avez persisté et présenté votre niveau de compréhension actuel

<.> Aperçu du contenu :

Opérations de base liées au processus : fork/exit/kill/wait
• Opérations avancées liées au processus : Le processus principal se termine et le processus enfant également se termine après avoir terminé son travail ; si le processus enfant se termine anormalement, le processus principal redémarre automatiquement
• Communication inter-processus (IPC) - pipe (pipe)
• Communication inter-processus (IPC) - file d'attente de messages (file d'attente de messages)
• Plus de fonctionnalités fournies par le module de processus swoole

Opérations de base liées aux processus

Quoi est un processus : Un processus est le programme du coureur

Regardons-le d'abord Regardons l'exemple le plus simple :

<?phpecho posix_getpid(); // 获取当前进程的 pidswoole_set_process_name(&#39;swoole process master&#39;); // 修改所在进程的进程名sleep(100); // 模拟一个持续运行 100s 的程序, 这样就可以在进程中查看到它, 而不是运行完了就结束

Voir le processus à travers

: ps aux

Le nom du processus n'est pas défini

Le nom du processus est défini

Regardons à nouveau swoole Opérations de base de l'utilisation des sous-processus :

use Swoole\Process;

$process = new Process(function (Process $worker) {    if (Process::kill($worker->pid, 0)) { // kill操作常用来杀死进程, 传入 0 可以用来检测进程是否存在
        $worker->exit(); // 退出子进程
    }
});
$process->start(); // 启动子进程Process::wait(); // 回收退出的子进程

•  : Définissez la logique à exécuter par le sous-processus via la fonction de rappel new Process()

•  : Appelez l'appel système $process->start() pour générer un processus enfant fork()

•  : L'opération kill envoie un signal au processus, qui est souvent utilisé pour tuer le processus. Passer 0 peut être utilisé pour détecter s'il y a Process::kill()

  <. 🎜>
•  : Appelez l'

  appel système pour recycler le processus enfant. S'il n'est pas recyclé, le processus enfant programmera un Process::wait()processus zombiewait(), gaspillant les ressources du système

•  : Le processus enfant sort activement

  $worker->exit()

J'ai une question ici :

du processus principal Quelle est la vie Comment se déroule le cycle de vie d'un processus enfant ?

Une telle question vient aussi de mon inertie de pensée précédente :

Pour comprendre une chose, partez de la vie de la chose. Comprendre le cycle

Combiné avec Un processus est un programme en cours d'exécution pour comprendre ensemble :

 : Seule la logique de la fonction de rappel sera exécutée dans le processus
• new Process()Un autre code est exécuté dans le processus principal

Opérations avancées liées au processus

Le processus principal quitte l'enfant processus Quittez également après avoir terminé le travail

• Le processus enfant se termine anormalement et le processus principal redémarre automatiquement

• <?phpuse Swoole\Process;class MyProcess1{    public $mpid = 0; // master pid, 即当前程序的进程ID
      public $works = []; // 记录子进程的 pid
      public $maxProcessNum = 1;    public $newIndex = 0;    public function __construct()
      {        try {
              swoole_set_process_name(__CLASS__. &#39; : master&#39;);            $this->mpid = posix_getpid();            $this->run();            $this->processWait();
          } catch (\Exception $e) {            die(&#39;Error: &#39;. $e->getMessage());
          }
      }    public function run()
      {        for ($i=0; $i<$this->maxProcessNum; $i++) {            $this->createProcess();
          }
      }    public function createProcess($index = null)
      {        if (is_null($index)) {
              $index = $this->newIndex;            $this->newIndex++;
          }
          $process = new Process(function (Process $worker) use($index) { // 子进程创建后需要执行的函数
              swoole_set_process_name(__CLASS__. ": worker $index");            for ($j=0; $j<3; $j++) { // 模拟子进程执行耗时任务
                  $this->checkMpid($worker);                echo "msg: {$j}\n";
                  sleep(1);
              }
          }, false, false); // 不重定向输入输出; 不使用管道
          $pid = $process->start();        $this->works[$index] = $pid;        return $pid;
      }    // 主进程异常退出, 子进程工作完后退出
      public function checkMpid(Process $worker) // demo中使用的引用, 引用表示传的参数可以被改变, 由于传入 $worker 是 \Swoole\Process 对象, 所以不用使用 &    {        if (!Process::kill($this->mpid, 0)) { // 0 可以用来检测进程是否存在
              $worker->exit();
              $msg = "master process exited, worker {$worker->pid} also quit\n"; // 需要写入到日志中
              file_put_contents(&#39;process.log&#39;, $msg, FILE_APPEND); // todo: 这句话没有执行
          }
      }    // 重启子进程
      public function rebootProcess($pid)
      {
          $index = array_search($pid, $this->works);        if ($index !== false) {
              $newPid = $this->createProcess($index);            echo "rebootProcess: {$index}={$pid}->{$newPid} Done\n";            return;
          }        throw new \Exception("rebootProcess error: no pid {$pid}");
      }    // 自动重启子进程
      public function processWait()
      {        while (1) {            if (count($this->works)) {
                  $ret = Process::wait(); // 子进程退出
                  if ($ret) {                    $this->rebootProcess($ret[&#39;pid&#39;]);
                  }
              } else {                break;
              }
          }
      }
  }new MyProcess1();

Expliquez les points suivants :

Après le le processus enfant termine son exécution, il quittera, via

détecte le signal de sortie du sous-processus et effectue un redémarrage automatique, le sous-processus continuera à s'exécuter
• Process::wait() Concernant les paramètres de fonction passant
référence/pointeur
• , une bonne façon de le comprendre est : Les paramètres peuvent être modifiés
Exécuter et simuler le processus principal pour sortir anormalement :

Simuler le processus principal sortir anormalement

Sortie

Communication Inter-Processus (IPC) - Pipe (pipe)

Plusieurs mots-clés de pipeline :

Half-duplex : flux de données unidirectionnel, une extrémité est en lecture seule et l'autre extrémité est en écriture seule

• Synchrone ou asynchrone : la valeur par défaut est le mode de blocage synchrone.
pour ajouter un canal à la boucle d'événements de swoole pour implémenter une IO asynchrone
• swoole_event_add()type de canal (format de données) :
, streaming, les utilisateurs doivent traiter eux-mêmes la mise en paquets/déballage des données < ; 🎜>, datagramme, chaque envoi et réception est un paquet de données complet (
• )SOCK_STREAMSOCK_DGRAM DGRAM/STREAMRemarque, swoole wiki - process->write() mentionne que
ne perdra pas de paquets de commande

Regardons d'abord un exemple simple, php lit les données du tube shell :SOCK_DGRAM

// get pip data$fp = fopen('php://stdin', 'r');if ($fp) {    while ($line = fgets($fp, 4096)) {        echo "php get pip data: ". $line;
    }
    fclose($fp);
}

Lire les données du tube shell

Le processus pipe in swoole est très puissant , prenant en charge l'

écriture du processus enfant, la lecture du processus principal

et

l'écriture du processus principal, le sous-processus lit  :

use Swoole\Process;// 子进程写, 父进程读$process = new Process(function (Process $worker) {
    $worker->write("worker");
});
$process->start();
$msg = $process->read();echo "from process: $msg", "\n";// 父进程写, 子进程读$process = new Process(function (Process $worker) {
    $msg = $worker->read();    echo "from master: $msg", "\n";
});
$process->start();
$process->write('master');

utilise des tuyaux pour lire et écrire plusieurs fois

. Faites attention à la distinction entre

et

J'ai pensé à tort que ces deux-là étaient identiques, mais en fait, ils le sont. Erreur

en tant que processus enfant, ce qui équivaut à $worker->write() être l'enfant. processus écrivant le tube - en fait, c'est la logique exécutée dans le processus principal. Le processus principal écrit des données dans le tube pour que le processus enfant les lise $process->write()$processAutres opérations liées au pipeline dans swoole :$process->write()

E/S asynchrones

use Swoole\Process;use Swoole\Event;// 异步IO$process = new Process(function (Process $worker) {
    $GLOBALS['worker'] = $worker;
    Event::add($worker->pipe, function (int $pipe) { // 使用 swoole_event_add 添加管道到异步IO
        /** @var Process $worker */
        $worker = $GLOBALS['worker'];
        $msg = $worker->read();        echo "from master: $msg \n";
        $worker->write("hello master");
        sleep(2);
        $worker->exit(0);
    });
});
$process->start();
$process->write("master msg 1");
$msg = $process->read();echo "from process: $msg \n";

• E/S asynchrones

Définir le délai d'attente

use Swoole\Process;// 设置管道超时$process = new Process(function (Process $worker) {
    sleep(5);
});
$process->start();
$process->setTimeout(0.5);
$ret = $process->read();
var_dump($ret);
var_dump(swoole_errno());

• Délai d'expiration du pipeline

插播一个趣事, @thinkpc 看完 2017北京PHP开发者年会, 就知道为啥会点赞了

• 关闭管道

// 关闭管道: 默认值0->关闭读写 1->关闭写 2->关闭读$process->close();

进程间通信(IPC) - 消息队列(message queue)

消息队列:

• 一系列保存在内核中的消息链表
• 有一个 msgKey, 可以通过此访问不同的消息队列
• 有数据大小限制, 默认 8192, 可以通过内核修改
• 阻塞 vs 非阻塞: 阻塞模式下 pop()空消息队列/push()满消息队列会阻塞, 非阻塞模式可以直接返回

swoole 中使用消息队列:

• 通信模式: 默认为争抢模式, 无法将消息投递给指定子进程
• 新建消息队列后, 主进程就可以使用
• 消息队列不可和管道一起使用, 也无法使用 swoole event loop
• 主进程中要调用 wait(), 否则子进程中调用 pop()/push() 会报错

use Swoole\Process;
$process = new Process(function (Process $worker) {    // $worker->push('worker');
    echo "from master: ". $worker->pop(). "\n";
    sleep(2);    // $worker->exit();}, false, false); // 关闭管道// 参数一为 msgKey, 这里是默认值// 参数二为 通信模式, 默认值 2 表示争抢模式, 这里还加上了 非阻塞$process->useQueue(ftok(__FILE__, 1), 2| Process::IPC_NOWAIT);
$process->push('hello1'); // 使用 useQueue 后, 主进程就可以读写消息队列了$process->push('hello2');echo "from woker: ". $process->pop(). "\n";// echo "from woker: ". $process->pop(). "\n";$process->start(); // 启动子进程// 消息队列状态var_dump($process->statQueue());// 删除队列, 如果不调用则不会在程序结束时清楚数据, 下次使用相同 msgKey 时还可以访问数据$process->freeQueue();
var_dump(Process::wait()); // 要调用 wait(), 否则子进程中 push()/pop() 会报错

消息队列

swoole process 模块提供的更多功能

• swoole_set_process_name(): 修改进程名, 不兼容 mac

• swoole_process->exec(string $execfile, array $args) 执行外部程序

参数 $execfile 需要使用可执行文件的绝对路径, 参数 args 为参数数组

// 比如 python test.py 123swoole_process->exec('/usr/bin/python', ['test.py', 123]);// 更复杂的例子swoole_process->exec(('/usr/local/bin/php', ['/var/www/project/yii-best-practice/cli/yii', 't/index', '-m=123', 'abc', 'xyz']);// 父进程 exec 进程进行管道通信use Swoole\Process;
$process = new Process(function (Process $worker) {
    $worker->exec('/bin/echo', ['hello']);
    $worker->write('hello');
}, true); // 需要启用标准输入输出重定向$process->start();echo "from exec: ". $process->read(). "\n";

父进程与exec进程通过管道通信

• \Swoole\Process::kill($pid, $signo = SIGTERM): 向指定进程发送信号, 默认是终止进程, 传 0 可检测进程是否存在

• \Swoole\Process::wait(): 回收子进程, 如果主进程不调用此方法, 子进程会变成 僵尸进程, 浪费系统资源

• \Swoole\Process::signal(): 异步信号监听

use Swoole\Process;// 异步信号监听 + waitProcess::signal(SIGCHLD, function ($signal) { // 监听子进程退出信号
    // 可能同时有多个子进程退出, 所以要while循环
    while ($ret = Process::wait(false)) { // false 表示不阻塞
        var_dump($ret);
    }
});

\Swoole\Process::daemon(): 将当前进程变为一个守护进程

use Swoole\Process;// daemonProcess::daemon();
swoole_set_process_name('test daemon process');
sleep(100);

daemon-守护进程

• \Swoole\Process::alarm(): 高精度定时器(微秒级), 对 setitimer 系统调用的封装, 可以配合 \Swoole\Process::signal() / pcntl_signal 使用

注意不可和 \Swoole\Timer 同时使用

// signal + alarm// 第一个参数表示时间, 单位 us, -1 表示清除定时器// 第二个参数表示类型 0->真实时间->SIGALAM 1->cpu时间->SIGVTALAM 2->用户态+内核态时间->SIGPROFProcess::alarm(100*1000); // 100msProcess::signal(SIGALRM, function ($signal) {    static $i = 0;    echo "#$i \t alarm \n";
    $i++;    if ($i>20) {
        Process::alarm(-1); // -1 表示清除
    }
});

alarm

• \Swoole\Process::setaffinity(): 设置CPU亲和, 即将进程绑定到指定CPU核上

传值范围: [0, swoole_cpu_num())
CPU亲和: CPU的速度远远高于IO的速度, 所以CPU有多级缓存来解决IO等待的问题, 绑定指定CPU, 更容易命中CPU缓存

写在最后

资源推荐:

• 图灵社区 - 理解UNIX进程 + 「理解Unix进程」读书笔记
• blog - 「进程」编程

todo:

• 使用输入输出重定向
• 管道类型为 SOCK_STREAM 时的情况, 是否需要 封包/解包 处理, 即 swoole wiki - process->write() 中提到的 管道通信默认的方式是流式，write写入的数据在read可能会被底层合并
• 多进程 + 异步IO 的注意事项

能理解 因为子进程会继承父进程的内存和IO句柄 这个会产生的影响, 但是给的示例并没有说明这个问题

use Swoole\Process;use Swoole\Event;// 多个子进程 + 异步IO$workers = [];
$workerNum = 3;for ($i=0; $i<$workerNum; $i++) {
    $process = new Process(function (Process $worker) {
        $worker->write($worker->pid);        echo "worker: {$worker->pid} \n";
    });
    $pid = $process->start();
    $workers[$pid] = $process;    // Event::add($process->pipe, function (int $pipe) use ($process) {
    //  $data = $process->read();
    //  echo "recv: $data \n";
    // });}foreach ($workers as $worker) {
    Event::add($worker->pipe, function (int $pipe) use ($worker) {
        $data = $worker->read();        echo "recv: $data \n";
    });
}

多进程异步IO

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!