La colonne
1. Aucun état n'est partagé entre les processus
. 🎜> 2. La planification des processus est effectuée par le système d'exploitation
3. Chaque processus possède son propre espace mémoire indépendant
4. La communication inter-processus est principalement réalisée par la transmission du signal. l'efficacité de la communication de toute méthode, telle que les sémaphores, les canaux, les événements, etc., doit passer par le noyau, ce qui entraîne une efficacité de communication relativement faible
1. Le partage de variables entre les threads résout le problème de communication gênante. L'accès aux variables nécessite des verrous
2. Un processus peut avoir plusieurs threads, mais chacun d'eux sera partagé. ressources demandées par le système d'exploitation au processus parent, y compris la mémoire virtuelle, les fichiers, etc. Puisqu'il s'agit de ressources partagées, les ressources système requises pour créer des threads sont beaucoup plus petites que celles des processus, et le nombre correspondant de threads pouvant être créés est également devenu relativement important.
1. Processus maître : processus principal
2. Processus manager : processus de gestion
3 , Processus de travail : Processus de travail
1.1. MainReactor (thread principal)
1.2, Groupe de threads Reactor
Le thread Reactor est responsable du maintien de la connexion TCP de la machine client, du traitement des E/S du réseau et de l'envoi et de la réception de données de manière complètement asynchrone et non -mode blocage.
1.3. Fil de détection des paquets de battements de cœur (HeartbeatCheck)
Une fois que Swoole a configuré la détection des battements de cœur, le fil de détection des paquets de battements de cœur enverra la détection à toutes les connexions précédemment en ligne
1.4, fil de réception de paquets UDP (UdpRecv)
Le processus de travail appartient au processus logique principal de swoole. L'utilisateur traite une série de requêtes du client, accepte le paquet de requêtes fourni par le thread Reactor et exécute la fonction de rappel PHP pour traiter. les données pour générer les données de réponse et les envoie au thread Reactor. , envoyées par le thread Reactor au client TCP, peuvent être en mode asynchrone non bloquant, ou en mode de blocage synchrone
Le processus taskWorker est un processus de travail asynchrone fourni par swoole. Ces processus sont principalement utilisés pour gérer certaines tâches de synchronisation à long terme et les exécuter dans le processus de travail.
1. La requête du client atteint le réacteur principal. Le client se connecte effectivement à un thread du réacteur dans le processus maître.
2. Le Reactor principal enregistre la demande auprès du Reactor correspondant en fonction de la situation du Reactor (chaque Reactor a epoll. Il est utilisé pour surveiller les changements dans le client)
Quand il y a des changements. dans le client, le réacteur transmet les données au travailleur pour traitement
4. Une fois le traitement terminé, le travailleur les envoie au réacteur correspondant via une communication inter-processus (telle que des tuyaux, une mémoire partagée, des files d'attente de messages) .
5. Reactor envoie le résultat de la réponse au traitement de demande de connexion correspondant
<?php //tcp协议$server=new Swoole\Server("0.0.0.0",9800); //创建server对象$server->set([
'worker_num'=>3, //设置进程
//'heartbeat_idle_time'=>10,//连接最大的空闲时间
//'heartbeat_check_interval'=>3 //服务器定时检查
'open_length_check'=>1,
'package_length_type'=>'N',//设置包头的长度
'package_length_offset'=>0, //包长度从哪里开始计算
'package_body_offset'=>4, //包体从第几个字节开始计算
'package_max_length'=>1024 * 1024 * 2,]);$server->on("Start",function (){
var_dump(1);
//设置主进程的名称
swoole_set_process_name("server-process:master");});//服务关闭时候触发(信号)$server->on("shutdown",function (){});//当管理进程启动时调用它$server->on('ManagerStart',function (){
var_dump(2);
//swoole_set_process_name("server-process:manger");});$server->on('WorkerStart',function ($server,$workerId){
// swoole_set_process_name("server-process:worker");
var_dump(3);});//监听事件,连接事件(woker进程当中)$server->on('connect',function ($server,$fd){
echo "新的连接进入:{$fd}".PHP_EOL;});//消息发送过来(woker进程当中)$server->on('receive',function (swoole_server $server, int $fd, int $reactor_id, string $data){
//var_dump("消息发送过来:".$data);
//服务端});//消息关闭$server->on('close',function (){
echo "消息关闭".PHP_EOL;});//服务器开启$server->start();echo '123456';1. Aucun état n'est partagé entre les processus
2. La planification des processus est effectuée par le système d'exploitation
3. .Chaque processus possède son propre espace mémoire indépendant
4. La communication inter-processus est principalement réalisée par la transmission de signaux. Il existe de nombreuses méthodes de mise en œuvre, telles que les sémaphores, les canaux, les événements, etc., et l'efficacité de la communication doit disparaître. via le noyau, ce qui entraîne une efficacité de communication relativement faible
5. Puisqu'il s'agit d'un espace mémoire indépendant, lors du changement de contexte, il est nécessaire de sauvegarder les informations de la première pile d'appels, les informations de chaque registre CPU, la mémoire virtuelle, et ouvrir le handle associé et d'autres informations, donc basculer entre les processus contextuels est très coûteux et la communication est gênante.
1. Le partage de variables entre les threads résout le problème de communication gênante. L'accès aux variables nécessite des verrous
2. Un processus peut avoir plusieurs threads, mais chaque thread partagera le processus parent. ressources du système d'exploitation, y compris la mémoire virtuelle, les fichiers, etc. Puisqu'il s'agit d'une ressource partagée, les ressources système requises pour créer un thread sont beaucoup plus petites que celles du processus, et le nombre correspondant de threads pouvant être créés devient relativement beaucoup plus grand.
3. De plus, en termes de planification, comme la mémoire est partagée, il y a moins de choses à sauvegarder lors du changement de contexte, afin que le changement de contexte devienne plus efficace.
1. Processus maître : processus principal
2. Processus manager : processus de gestion
3 , Processus de travail : Processus de travail
4. Processus de tâche : Processus de travail de tâche asynchrone
La première couche, Processus principal, c'est le processus principal de swoole, ce processus est utilisé pour traitement L'événement principal de swoole est piloté, donc dans ce processus, vous pouvez voir qu'il a un [thread] MainReactor et plusieurs [threads] Reactor. Toute la surveillance des événements de swoole sera implémentée dans ces threads, comme les connexions des clients, le traitement des signaux. etc.
1.1. MainReactor (thread principal)
Le thread principal sera chargé de surveiller le socket du serveur Si une nouvelle connexion est acceptée, le thread principal évaluera le nombre de connexions. pour chaque thread Reactor. Attribuez cette connexion au thread du réacteur avec le plus petit nombre de connexions pour effectuer l’équilibrage de charge.
1.2, Groupe de threads Reactor
Le thread Reactor est responsable du maintien de la connexion TCP de la machine client, du traitement des E/S du réseau et de l'envoi et de la réception de données de manière complètement asynchrone et non -mode blocage.
Après avoir accepté une nouvelle connexion, le thread principal de swoole attribuera la connexion à un thread Reactor fixe, lira les données lorsque le socket est lisible, effectuera une analyse de protocole et transmettra la requête au processus Worker. Envoie des données au client TCP lorsque le socket est accessible en écriture.
1.3. Fil de détection des paquets de battements de cœur (HeartbeatCheck)
Une fois que Swoole a configuré la détection des battements de cœur, le fil de détection des paquets de battements de cœur enverra la détection à toutes les connexions précédemment en ligne
dans un délai fixe. paquet
1.4, le thread de réception de paquets UDP (UdpRecv)
reçoit et traite le paquet de données udp client
swoole veut atteindre Pour le Pour obtenir de meilleures performances, plusieurs processus de travail doivent être créés pour aider à traiter les tâches, mais le processus de travail doit être fork. Cependant, l'opération fork n'est pas sécurisée, de nombreux processus zombies apparaîtront, ce qui affectera les performances du serveur. en même temps, le processus de travail sera tué par inadvertance ou sortie anormale pour des raisons de programme, afin d'assurer la stabilité du service, le processus de travail doit être recréé.
Swoole créera un processus de gestion distinct pendant le fonctionnement, et tous les processus de travail et les processus de tâches sont issus du processus de gestion. Le processus de gestion surveillera les événements de sortie de tous les processus enfants Lorsqu'une erreur fatale se produit dans le processus de travail ou que le cycle de vie en cours se termine, le processus de gestion recyclera le processus et créera un nouveau processus. En d'autres termes, le processus Manager "nanny" a toute autorité pour gérer la création et le recyclage des processus de travailleurs et de tâches
Le processus de travail appartient au processus logique principal de swoole et est géré par l'utilisateur Une série de requêtes du client accepte les paquets de requêtes livrés par le thread Reactor et exécute la fonction de rappel PHP pour traiter les données afin de générer des données de réponse et les envoyer au thread Reactor Les données de réponse envoyées par le thread Reactor. au client TCP peut être en mode asynchrone non bloquant ou en mode bloquant
Le processus taskWorker est un processus de travail asynchrone fourni par swoole. - chronométrer les tâches synchrones et les livrer dans le processus de travail.
1. La requête du client atteint le réacteur principal. Le client se connecte effectivement à un thread du réacteur dans le processus maître.
2. Le Reactor principal enregistre la demande auprès du Reactor correspondant en fonction de la situation du Reactor (chaque Reactor a epoll. Il est utilisé pour surveiller les changements dans le client)
Quand il y a des changements. dans le client Reactor, il transmet les données au travailleur pour traitement
4. Une fois le traitement terminé, le travailleur les envoie au réacteur correspondant via une communication inter-processus (telle que des tuyaux, une mémoire partagée, des files d'attente de messages).
5. Reactor envoie le résultat de la réponse à la demande de connexion correspondante et le traitement est terminé
<?php //tcp协议$server=new Swoole\Server("0.0.0.0",9800); //创建server对象$server->set([
'worker_num'=>3, //设置进程
//'heartbeat_idle_time'=>10,//连接最大的空闲时间
//'heartbeat_check_interval'=>3 //服务器定时检查
'open_length_check'=>1,
'package_length_type'=>'N',//设置包头的长度
'package_length_offset'=>0, //包长度从哪里开始计算
'package_body_offset'=>4, //包体从第几个字节开始计算
'package_max_length'=>1024 * 1024 * 2,]);$server->on("Start",function (){
var_dump(1);
//设置主进程的名称
swoole_set_process_name("server-process:master");});//服务关闭时候触发(信号)$server->on("shutdown",function (){});//当管理进程启动时调用它$server->on('ManagerStart',function (){
var_dump(2);
//swoole_set_process_name("server-process:manger");});$server->on('WorkerStart',function ($server,$workerId){
// swoole_set_process_name("server-process:worker");
var_dump(3);});//监听事件,连接事件(woker进程当中)$server->on('connect',function ($server,$fd){
echo "新的连接进入:{$fd}".PHP_EOL;});//消息发送过来(woker进程当中)$server->on('receive',function (swoole_server $server, int $fd, int $reactor_id, string $data){
//var_dump("消息发送过来:".$data);
//服务端});//消息关闭$server->on('close',function (){
echo "消息关闭".PHP_EOL;});//服务器开启$server->start();echo '123456';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!
La différence entre les threads et les processus
Comment afficher les processus sous Linux
processus d'affichage Linux
Pourquoi swoole peut-il résider en mémoire ?
Comment convertir un singe en wav
Le papier A5 est-il plus grand ou le papier B5 plus grand ?
Code source du site Web gratuit
La page Web s'ouvre lentement
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
