conception pilotée par les événements php

Cet article présente principalement la conception basée sur les événements PHP. Maintenant, je le partage avec vous. Les amis dans le besoin peuvent s'y référer

Cet article décrit la conception basée sur les événements PHP avec des exemples. Partagez-le avec tout le monde pour référence, les détails sont les suivants :

Je travaillais récemment sur un projet qui nécessitait l'utilisation de PHP asynchrone. Lorsque j'ai parcouru le code source PHP, j'ai trouvé trois modules inutilisés. , sysvsem, sysvshm, sysvmsg, Après quelques recherches, j'en ai beaucoup bénéficié.

Il existe une telle famille de fonctions en php. Ce sont des packages de la famille de fonctions v ipc d'Unix.
Ils sont rarement utilisés, mais ils sont puissants. En les utilisant judicieusement, vous obtiendrez deux fois le résultat avec la moitié de l’effort.

Ils comprennent :

Sémaphores
Mémoire partagée
Messagerie inter-processus (ipc)

Sur la base de ceux-ci, il est entièrement Il nous est possible de regrouper PHP dans un système piloté par messages.

Mais, d'abord, nous devons introduire quelques bases importantes :

1 ftok

int ftok ( string pathname, string. proj )

ftok convertit un chemin d'accès et un nom de projet (doit contenir un caractère) en une clé entière utilisée pour utiliser le système v ipc

2. ticks

Les coches n'ont été ajoutées à PHP qu'à partir de PHP 4.0.3. Il s'agit d'un événement qui se produit chaque fois que l'interpréteur exécute n instructions de bas niveau dans le segment de code de déclaration. La valeur de n est spécifiée avec ticks=n dans la partie directive de declare.

function getstatus($arg){
  print_r(connection_status());
  debug_print_backtrace();
}
reigster_tick_function("getstatus", true);
declare(ticks=1){
  for($i =1; $i<999; $i++){
 echo "hello";
 }
}
unregister_tick_function("getstatus");

C'est fondamentalement équivalent à :

function getstatus($arg){
  print_r(connection_status());
  debug_print_backtrace();
}
reigster_tick_function("getstatus", true);
declare(ticks=1){
  for($i =1; $i<999; $i++){
 echo "hello"; getstatus(true);
 }
}
unregister_tick_function("getstatus");

message, Je vais maintenant utiliser un exemple pour illustrer comment combiner les ticks pour implémenter la communication par message PHP.

$mesg_key = ftok(__file__, 'm');
$mesg_id = msg_get_queue($mesg_key, 0666);
function fetchmessage($mesg_id){
 if(!is_resource($mesg_id)){
  print_r("mesg queue is not ready");
 }
 if(msg_receive($mesg_id, 0, $mesg_type, 1024, $mesg, false, msg_ipc_nowait)){
  print_r("process got a new incoming msg: $mesg ");
 }
}
register_tick_function("fetchmessage", $mesg_id);
declare(ticks=2){
 $i = 0;
 while(++$i < 100){
  if($i%5 == 0){
msg_send($mesg_id, 1, "hi: now index is :". $i);
  }
 }
}
//msg_remove_queue($mesg_id);

Dans cet exemple, ajoutez d'abord notre processus d'exécution php à la file d'attente des messages obtenue par la clé générée par ftok .

Ensuite, en cochant, interrogez la file d'attente des messages une fois toutes les deux instructions.

Ensuite l'envoi du message est simulé.

Accédez à ce script dans le navigateur et le résultat est le suivant :

process got a new incoming msg: s:19:"hi: now index is :5";
process got a new incoming msg: s:20:"hi: now index is :10";
process got a new incoming msg: s:20:"hi: now index is :15";
process got a new incoming msg: s:20:"hi: now index is :20";
process got a new incoming msg: s:20:"hi: now index is :25";
process got a new incoming msg: s:20:"hi: now index is :30";
process got a new incoming msg: s:20:"hi: now index is :35";
process got a new incoming msg: s:20:"hi: now index is :40";
process got a new incoming msg: s:20:"hi: now index is :45";
process got a new incoming msg: s:20:"hi: now index is :50";
process got a new incoming msg: s:20:"hi: now index is :55";
process got a new incoming msg: s:20:"hi: now index is :60";
process got a new incoming msg: s:20:"hi: now index is :65";
process got a new incoming msg: s:20:"hi: now index is :70";
process got a new incoming msg: s:20:"hi: now index is :75";
process got a new incoming msg: s:20:"hi: now index is :80";
process got a new incoming msg: s:20:"hi: now index is :85";
process got a new incoming msg: s:20:"hi: now index is :90";
process got a new incoming msg: s:20:"hi: now index is :95";

Avez-vous vu cela ? Tout le monde a déjà compris ? comment simuler php as Vous avez déjà une notion d'événementiel ? Ne vous inquiétez pas, nous continuerons à nous améliorer.

2. Sémaphore

Tout le monde devrait être familier avec le concept de sémaphore. Grâce aux sémaphores, la communication de processus, la compétition, etc. peuvent être réalisées. Je n'entrerai pas encore dans les détails, mais lister simplement l'ensemble de fonctions de sémaphore fourni en PHP

sem_acquire -- acquérir un sémaphore
sem_get -- obtenir un identifiant de sémaphore
sem_release -- libérer un sémaphore
sem_remove -- supprimer un sémaphore

Pour des informations spécifiques, vous pouvez lire le manuel php.

3. Partage de mémoire

php sysvshm propose une solution de partage de mémoire : sysvshm, qui est dans la même série que sysvsem et sysvmsg, mais ici, je ne m'en passe pas en l'utilisant, j'ai utilisé la série de fonctions shmop, combinée avec des ticks

function memoryusage(){
 printf("%s: %s<br/>", date("h:i:s",time()), memory_get_usage());
 //var_dump(debug_backtrace());
 //var_dump(__function__);
 //debug_print_backtrace();
}
register_tick_function("memoryusage");
declare(ticks=1){
$shm_key = ftok(__file__, &#39;s&#39;);
$shm_id = shmop_open($shm_key, &#39;c&#39;, 0644, 100);
}
printf("size of shared memory is: %s<br/>", shmop_size($shm_id));
$shm_text = shmop_read($shm_id, 0, 100);
eval($shm_text);
if(!empty($share_array)){
 var_dump($share_array);
 $share_array[&#39;id&#39;] += 1;
}else{
 $share_array = array(&#39;id&#39; => 1);
}
$out_put_str = "$share_array = " . var_export($share_array, true) .";";
$out_put_str = str_pad($out_put_str, 100, " ", str_pad_right);
shmop_write($shm_id, $out_put_str, 0);
?>

pour exécuter cet exemple et actualiser en continu. croissant.

La simple utilisation de ce shmop peut compléter les fonctions de partage de données entre les scripts php : ainsi que la mise en cache, le comptage, etc.

Recommandations associées :

Implémentation du mécanisme d'événements PHP

Analyse détaillée : À propos des problèmes liés aux événements PHP_Tutoriel 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!