PHP
Multitraitement

Multiprocessing utilisant des fonctions de fourche intégrées

Vous pouvez utiliser des fonctions intégrées pour exécuter des processus PHP sous forme de fourchettes. C'est le moyen le plus simple de réaliser un travail parallèle si vous n'avez pas besoin que vos threads se parlent.

Cela vous permet de placer des tâches exigeantes (comme télécharger un fichier sur un autre serveur ou envoyer un courrier électronique) à un autre thread pour que votre script se charge plus rapidement et puisse utiliser plusieurs cœurs. savoir ce que font les enfants.

Notez que sous Windows, une nouvelle invite de commande apparaîtra pour chaque fourchette démarrée.

master.php

$cmd = "php worker.php 10";
if(strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') // for windows use popen and pclose
{
    pclose(popen($cmd,"r"));
}
else //for unix systems use shell exec with "&" in the end
{
    exec('bash -c "exec nohup setsid '.$cmd.' > /dev/null 2>&1 &"');
}

worker.php

//send emails, upload files, analyze logs, etc
$sleeptime = $argv[1];
sleep($sleeptime);

Créer un processus enfant à l'aide de fork

PHP a intégré la fonction pcntl_fork pour créer un processus enfant. pcntl_fork est identique à fork dans unix. Il ne prend aucun paramètre et renvoie un entier qui peut être utilisé pour différencier le processus parent et le processus enfant. Considérez le code suivant pour l'explication

<?php
    // $pid is the PID of child
    $pid = pcntl_fork();
    if ($pid == -1) {
         die('Error while creating child process');
    } else if ($pid) {
         // Parent process
    } else {
         // Child process
    }
?>

Comme vous pouvez le voir, -1 est une erreur dans fork et l'enfant n'a pas été créé. Lors de la création d'un enfant, nous avons deux processus en cours d'exécution avec un PID séparé.

Une autre considération est un zombie process ou un zombie process defunct process lorsque le processus parent se termine avant le processus enfant. Pour empêcher un processus zombie, ajoutez simplement pcntl_wait($status) à la fin du processus parent.

pnctl_wait suspend l'exécution du processus parent jusqu'à la fin du processus enfant.

Il est également intéressant de noter que le zombie process peut pas être tué en utilisant le signal SIGKILL .

Communication interprocessus

La communication interprocessus permet aux programmeurs de communiquer entre différents processus. Par exemple, considérons que nous devons écrire une application PHP capable d'exécuter les commandes bash et d'imprimer la sortie. Nous utiliserons proc_open , qui exécutera la commande et renverra une ressource avec laquelle nous pouvons communiquer. Le code suivant montre une implémentation de base qui exécute pwd dans bash partir de php

<?php
    $descriptor = array(
        0 => array("pipe", "r"), // pipe for stdin of child
        1 => array("pipe", "w"), // pipe for stdout of child
    );
    $process = proc_open("bash", $descriptor, $pipes);
    if (is_resource($process)) {
        fwrite($pipes[0], "pwd" . "\n");
        fclose($pipes[0]);
        echo stream_get_contents($pipes[1]);
        fclose($pipes[1]);
        $return_value = proc_close($process);

    }
?>

proc_open exécute la commande bash avec $descriptor tant que spécifications de descripteur. Après cela, nous utilisons is_resource pour valider le processus. Une fois cela fait, nous pouvons commencer à interagir avec le processus fils en utilisant $ pipes qui est généré selon les spécifications du descripteur.

Après cela, nous pouvons simplement utiliser fwrite pour écrire dans stdin du processus enfant. Dans ce cas, pwd suivi du retour chariot. Enfin, stream_get_contents est utilisé pour lire stdout du processus enfant.

Rappelez-vous toujours de fermer le processus enfant en utilisant proc_close () qui mettra fin à l'enfant et renverra le code de statut de sortie.