Comprendre brièvement le sémaphore de la communication des processus PHP

Cet article vous apporte des connaissances pertinentes sur PHP Le sémaphore est également appelé sémaphore et sémaphore. Il est utilisé pour résoudre le processus (problème de synchronisation des threads). Obtenez le verrou avant d'y accéder (impossible de l'obtenir). attendez) et libérez le verrou après l'accès. L'article le présente en détail à travers l'exemple de code. J'espère que cela sera utile à tout le monde.

(Tutoriel recommandé : Tutoriel vidéo PHP)

Méthodes de communication de processus courantes

Quelques bases théoriques

• Ressources critiques : ressources auxquelles un seul processus est autorisé à accéder à la fois.
• Section critique : la section de code de chaque processus qui accède aux ressources critiques est appelée la section critique

La section dite critique (également appelée section critique) est le segment de code qui accède et exploite les données partagées.

Exclusion mutuelle de processus : deux processus ou plus ne peuvent pas entrer simultanément dans la zone critique sur le même ensemble de variables partagées, c'est-à-dire qu'un processus accède aux ressources critiques et l'autre processus doit attendre avant d'y accéder.

Synchronisation des processus : elle étudie principalement comment déterminer l'ordre d'exécution entre plusieurs processus et éviter les problèmes de concurrence des données, c'est-à-dire comment faire en sorte que plusieurs processus fonctionnent bien ensemble

La soi-disant synchronisation signifie que les processus/threads simultanés sont dans certains Dans certaines situations clés, les points peuvent avoir besoin de s'attendre les uns les autres et d'échanger des messages. Cette attente et cet échange d'informations mutuellement restreints sont appelés synchronisation processus/thread.

Pour donner un exemple de synchronisation dans la vie, vous avez faim et voulez manger. Vous demandez à votre mère de cuisiner tôt. Après avoir entendu cela, votre mère commence à cuisiner, mais avant que votre mère ait fini de cuisiner, vous devez bloquer et l'attendre. pour terminer la cuisson. Une fois votre repas terminé, vous en serez naturellement informé et vous pourrez alors continuer votre repas.

Notez que la synchronisation et l'exclusion mutuelle sont deux concepts différents :

La synchronisation est comme : "L'opération A doit être exécutée avant l'opération B", "L'opération C doit être exécutée une fois l'opération A et l'opération B terminées", etc. ;

L'exclusion mutuelle est comme : « L'opération A et l'opération B ne peuvent pas être exécutées en même temps » ;

Sémaphore du système V

Utilisation du sémaphore : principalement utilisé pour le contrôle d'accès multi-processus ou multi-thread aux objets de ressources publiques. Utilisé pour résoudre le problème du multi-processus (synchronisation multi-thread), similaire à un verrou, acquérir le verrou avant d'accéder (attendre s'il n'est pas acquis) et libérer le verrou après l'accès.

Plusieurs processus/multithreads sont généralement exécutés simultanément. Si l'accès aux ressources publiques n'est pas synchronisé, il est facile de provoquer une corruption des données

Le sémaphore est en fait un compteur entier, principalement utilisé pour réaliser une exclusion mutuelle et une synchronisation entre les processus, au lieu de mise en cache des données pour la communication inter-processus.

Le sémaphore représente le nombre de ressources. Il existe deux opérations atomiques pour contrôler le sémaphore :

L'une est l'opération P. Cette opération soustraira -1 au sémaphore. Après soustraction, si le sémaphore = 0 après soustraction, cela indique qu'il y a encore des ressources disponibles et que le processus peut continuer à s'exécuter normalement.

L'autre est l'opération V. Cette opération ajoutera 1 au sémaphore. Après l'ajout, si le sémaphore 0, cela indique qu'il n'y a actuellement aucun processus bloqué ; l'opération

P est utilisée avant d'entrer dans la ressource partagée, et l'opération V est utilisée après avoir quitté la ressource partagée. par paires.

Par exemple, le sémaphore de 2 ressources équivaut à 2 voies de train. Le processus de fonctionnement PV est le suivant :

Un train entre sur la voie, ce qui équivaut au fonctionnement P du sémaphore, et la ressource. est -1, donc Il ne reste qu'une seule voie

Puis un autre train occupe une autre voie, qui est l'opération P, ressource -1

A ce moment, le feu passe au rouge car il n'y a pas voie disponible, et le troisième train doit attendre

Le premier train quitte la voie, ce qui équivaut à l'opération V A ce moment, la ressource voie est de 1 et le feu tricolore passe au vert

Le troisième. le train constate que le feu de circulation passe au vert, donc il entre sur la voie ferrée, les ressources de la voie sont épuisées à 0, donc le feu de circulation passe au rouge

Dans ce système de voie ferrée, la voie est une ressource publique, chaque train est comme un fil, et le feu tricolore joue le rôle de sémaphore. Le sémaphore peut réaliser l'opération d'exclusion mutuelle du verrou, et peut également réaliser la synchronisation processus/thread

Type de sémaphore

1) Sémaphore binaire (également appelé sémaphore binaire)

À ce moment, la valeur initiale du sémaphore peut être seulement 0 et 1. (Le sémaphore binaire peut implémenter l'opération de verrouillage mutex)

2) Sémaphore général/de comptage

À ce stade, la valeur initiale du sémaphore peut être n'importe quel nombre non négatif. Évidemment, il contient un sémaphore binaire. L'exemple de voie ferrée mentionné ci-dessus peut être implémenté à l'aide d'un sémaphore de comptage. Généralement, la différence entre un sémaphore de comptage et un verrou est qu'il permet à plusieurs threads/processus (le nombre de threads est défini par la valeur initiale du sémaphore de comptage). exploiter des ressources publiques en même temps

Généralement, vous pouvez rencontrer des scénarios dans lesquels vous devez utiliser des sémaphores uniquement lors du développement de plusieurs processus. Il n'existe presque aucun scénario dans lequel des sémaphores sont utilisés en PHP. Même s'il existe plusieurs processus fonctionnant sur des ressources publiques, les verrous de fichiers flock sont principalement utilisés pour les opérations d'exclusion mutuelle

php simule le fonctionnement multi-processus des ressources publiques

<?php
$file = "num.txt";//定一个空文件
$count =0;
file_put_contents($file,$count);

$pid = pcntl_fork();//fork 一个进程

if($pid == 0){//子进程执行逻辑
    $x = (int)file_get_contents($file);//读取文件内容
    //i 循环累加
    for($i=0; $i<1000; $i++){
        $x = $x + 1;
    }
    //写入文件
    file_put_contents($file,$x);
    //子进程退出
    exit(0);
}
//父进程执行逻辑
$x = (int)file_get_contents($file);
for($i=0; $i<1000; $i++){
    $x = $x+1;
}
//累加写入
file_put_contents($file,$x);

Aide à l'écriture d'un script shell

#!/bin/bash
for a in {1..1000}
do
    (php demo1.php)
    b=`cat num.txt`
    if [ $b != 2000 ]
    then
        echo -e "错误$b"
    fi
done

Logiquement parlant, la dernière valeur écrite dans le fichier par la variable $ x devrait être 2000, mais malheureusement, ce n'est pas le cas. Alors, exécutons le script ci-dessus : $x 最后写入文件的值应该是2000，但很不幸，并不是如此，我们对上面的脚本执行一下：

运行了1000次，发现出现了变量$x值结果是 1000 的有8次，虽然发生错误的概率比较小，但是在计算机里是不能容忍的。

为什么会出现这种情况，我们知道单核cpu系统里为了实现多个程序同时运行的假象，操作系统通常都采用时间片调度，一个进程时间片用完就切换下一个进程运行，加上我们的高级语言不是每一行代码都是原子性的，比如x = (int)file_get_contents($file)

Exécutez-le 1 000 fois et constatez que la valeur de la variable $x apparaît 8 fois et que le résultat est de 1 000. Bien que le la probabilité d’une erreur est relativement faible, elle n’est pas tolérée dans un ordinateur.

Pourquoi cela se produit-il ? Nous savons que pour obtenir l'illusion de plusieurs programmes exécutés en même temps dans un système CPU monocœur, le système d'exploitation utilise généralement la planification par tranche de temps lorsque la tranche de temps d'un processus est utilisée. , le processus suivant est activé. Plus Toutes les lignes de code de notre langage de haut niveau ne sont pas atomiques. Par exemple, x = (int)file_get_contents($file) Cette ligne de code est indivisible pour nous, mais compilée en code assembleur [instructions machine] par le compilateur, elle peut être implémentée par plusieurs instructions, ce qui posera des problèmes si les instructions ne sont exécutées que la moitié du temps. La tranche allouée par le processus est utilisée ou interrompue par d'autres processus, cela peut endommager les données, entraînant des erreurs dans les résultats du calcul final

Utilisez PHP pour encapsuler la fonction de jeu de sémaphore du système v

<?php
$file = "num.txt";//定一个空文件
$count =0;
$key = ftok("demo1.php","x");
$sem_id = sem_get($key,1);// 第二个参数是个整数，表示设置信号量集，设置为1 把它当做二值信号量来用，用于互斥
file_put_contents($file,$count);
$pid = pcntl_fork();//fork 一个进程
if($pid == 0){//子进程执行逻辑
sem_acquire($sem_id); // P -1 操作 获取一个信号量 ， 如果为0表示资源被占用进程挂起等待信号量释放
    $x = (int)file_get_contents($file);//读取文件内容
    //i 循环累加
    for($i=0; $i<1000; $i++){
        $x = $x + 1;
    }
    //写入文件
    file_put_contents($file,$x);
       sem_release($sem_id); //V +1 操作 释放信号量
    //子进程退出
    exit(0);
}
//父进程执行逻辑
sem_acquire($sem_id); // P -1 操作  获取信号量， 如果为0表示资源被占用进程挂起等待信号量释放
$x = (int)file_get_contents($file);
for($i=0; $i<1000; $i++){
    $x = $x+1;
}
//累加写入
file_put_contents($file,$x);
sem_release($sem_id); //V +1 操作 释放信号量

Après avoir ajouté le sémaphore, il doit être garanti à 100% comme étant 2000, et d'autres valeurs n'apparaîtront jamais. 🎜(Tutoriel recommandé : 🎜Tutoriel vidéo PHP🎜)🎜

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!