PHP进程通信基础之信号量与共享内存通信_php技巧
这篇文章主要介绍了PHP进程通信基础知识中的信号量与共享内存通信的相关资料,有需要的小伙伴可以查看下
由于进程之间谁先执行并不确定,这取决于内核的进程调度算法,其中比较复杂。由此有可能多进程在相同的时间内同时访问共享内存,从而造成不可预料的错误。信号量这个名字起的令人莫名其妙,但是看其英文原意,就十分容易理解。
semaphore 英[ˈseməfɔ:(r)] vt. 发出信号,打旗语;
类似于指挥官的作用。
下面我们看下一个伪代码信号量的使用。
1、创建信号量唯一标识符
$ftok = ftok(__FILE__, 'a');
2、创建信号量资源ID
$sem_resouce_id = sem_get($ftok);
3、接受信号量
sem_acqure($sem_resource_id);
4、释放信号量
sem_release($sem_resource_id);
5、销毁信号量
sem_remove($sem_resource_id);
举个不文雅的例子,使我们容易理解这个信号量在生活中的用法。理解之后可以套用到我们编程领域。
一家公司只有一个卫生间。那么当有人上厕所的时候,都要获取一把锁(信号量),表示卫生间正在使用。代码如下:
sem_acqure($sem_resource_id);
那么员工上完厕所之后,就需要将锁打开,释放锁(信号量),表示现在可以允许别人使用。代码如下:
sem_release($sem_resource_id);
通过一个简单的锁,我们就能够知道当前的厕所(共享内存)是否可以使用。这个例子不雅观,但说明了问题。这篇博客也是有味道的博客,真是不容易。。。。以下是示例代码:
<?php //创建共享内存区域 $shm_key = ftok(__FILE__, 'a'); $shm_id = shm_attach($shm_key, 1024, 0755); //var_dump($shm_id);die(); resource(4) of type (sysvshm) const SHARE_KEY = 1; $child_list = []; //加入信号量 $sem_id = ftok(__FILE__, 'b'); $signal = sem_get($sem_id); //$signal resource(5) of type (sysvsem) for ($i = 0; $i < 3; $i++) { $pid = pcntl_fork(); if ($pid == -1) { exit("Fork fail!".PHP_EOL); } elseif ($pid == 0) { //获取信号量 sem_acquire($signal); if (shm_has_var($shm_id,SHARE_KEY)) { $count = shm_get_var($shm_id, SHARE_KEY); $count++; //模拟业务处理 $sec = rand(1, 3); sleep($sec); shm_put_var($shm_id, SHARE_KEY, $count); } else { $count = 0; $sec = rand(1, 3); sleep($sec); shm_put_var($shm_id, SHARE_KEY, $count); } echo "child process: ".getmypid()." is writing! now count is: $count ".PHP_EOL; //释放信号量 sem_release($signal); exit("child process".getmypid()."end".PHP_EOL); } else { $child_list[] = $pid; } } while (count($child_list) > 0) { foreach ($child_list as $key => $pid) { $status = pcntl_waitpid($pid, $status); if ($status > 0 || $status == -1) { unset($child_list[$key]); } } sleep(1); } $count = shm_get_var($shm_id, SHARE_KEY); echo " $count ".PHP_EOL; //销毁信号量 sem_remove($signal); shm_remove($shm_id); shm_detach($shm_id);

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Sujets chauds

Les amis qui en savent beaucoup sur les ordinateurs doivent savoir que les GPU ont une mémoire partagée, et de nombreux amis craignent que la mémoire partagée réduise la quantité de mémoire et affecte l'ordinateur, ils veulent donc l'éteindre. Voici un moyen de l'éteindre. . Voyons. Désactivez la mémoire partagée win10gpu : Remarque : La mémoire partagée du GPU ne peut pas être désactivée, mais sa valeur peut être définie sur la valeur minimale. 1. Appuyez sur DEL pour accéder au BIOS lors du démarrage. Certaines cartes mères doivent appuyer sur F2/F9/F12 pour entrer. Il existe de nombreux onglets en haut de l'interface du BIOS, notamment « Principal, Avancé » et d'autres paramètres. Recherchez le « Chipset ». " option. Recherchez l'option de configuration SouthBridge dans l'interface ci-dessous et cliquez sur Entrée pour entrer.

En tant que langage de programmation hautement concurrent, le mécanisme de coroutine intégré et les opérations multithread de Golang permettent un multitâche léger. Cependant, dans un scénario de traitement multi-processus, la communication et la mémoire partagée entre différents processus sont devenues des enjeux clés dans le développement de programmes. Cet article présentera la méthode d'application permettant de réaliser une mémoire partagée entre plusieurs processus dans Golang. 1. Comment implémenter plusieurs processus dans Golang Dans Golang, le traitement simultané multi-processus peut être implémenté de différentes manières, notamment fork, os.Process,

Utilisation et application de la fonction de mémoire partagée PHP La mémoire partagée fait référence à une technologie dans laquelle plusieurs processus accèdent au même espace mémoire en même temps. En programmation simultanée, la mémoire partagée peut être utilisée pour la communication inter-processus afin de réaliser le partage de données entre différents processus. PHP fournit également des fonctions de mémoire partagée associées. Cet article présentera l'utilisation des fonctions de mémoire partagée PHP et explorera quelques scénarios d'application pratiques. Utilisation des fonctions de mémoire partagée PHP fournit le module d'extension shmop, qui permet à PHP de fonctionner sur la mémoire partagée du système. Les fonctions fournies par ce module d'extension

Avec le développement d’Internet, de plus en plus de sites Web doivent contenir un grand nombre de demandes d’accès des utilisateurs. Lorsqu'il est confronté à une concurrence élevée, un serveur à processus unique atteint rapidement un goulot d'étranglement, empêchant les utilisateurs d'accéder normalement au site Web. Par conséquent, le multi-processus est devenu l’une des solutions efficaces pour résoudre les problèmes de concurrence élevée. Cet article présentera la technologie multi-processus en PHP pour améliorer la capacité du programme à gérer les requêtes simultanées tout en garantissant la qualité du programme. 1. Introduction au multi-processus En informatique, un processus fait référence à une instance de programme en cours d'exécution. Chaque processus possède son propre espace mémoire et ses propres ressources système.

La communication inter-processus (IPC) dans Go est implémentée via des canaux, des canaux et une mémoire partagée. Les tuyaux permettent aux coroutines d'écrire et de lire des données via les points de terminaison des tuyaux, tandis que les canaux garantissent l'atomicité des opérations d'envoi et de réception. La mémoire partagée permet un échange rapide de données en permettant aux processus d'accéder à la même mémoire, mais nécessite une synchronisation pour empêcher les accès simultanés.

En C++, la mémoire partagée et les files d'attente de messages sont deux méthodes de communication inter-processus couramment utilisées. Ils peuvent nous aider à partager des données et des informations entre différents processus, permettant une programmation plus efficace. La mémoire partagée est une zone de mémoire spéciale qui peut être partagée par plusieurs processus. L'utilisation de la mémoire partagée évite la surcharge liée à la copie des données et réduit le délai de transfert des données entre les processus. Pour utiliser la mémoire partagée en C++, vous devez inclure le fichier d'en-tête <sys/shm.h> et utiliser shmget, shmat, sh

Comment utiliser le module multitraitement pour la communication inter-processus dans Python 3.x Avec le développement de la technologie informatique, nous devons souvent effectuer plusieurs tâches en même temps en programmation. Pour mieux tirer parti des processeurs multicœurs, le module multitraitement de Python fournit un ensemble d'outils simples mais puissants pour créer des programmes simultanés. Le module multitraitement nous permet d'utiliser plusieurs processus en Python, qui peuvent s'exécuter simultanément et progresser en cas de besoin.

Développement Golang : Utiliser RPC pour réaliser une communication inter-processus nécessite des exemples de code spécifiques 1. Introduction RPCRPC (RemoteProcedureCall) est un protocole d'appel de procédure à distance, qui permet au client d'appeler des fonctions ou des méthodes du programme serveur situé sur l'ordinateur distant, tout comme Identique à l'appel de fonctions locales. RPC peut être implémenté à l'aide de différents protocoles réseau, tels que TCP, HTTP, etc. Dans les systèmes distribués, RPC est un mécanisme de communication important, souvent utilisé pour la communication entre processus ou entre nœuds de réseau.
