Concurrence et parallélisme en PHP

La concurrence et le parallélisme sont des concepts essentiels de la programmation moderne, permettant aux applications d'effectuer plusieurs tâches simultanément, soit par exécution entrelacée (concurrence) soit par exécution simultanée (parallélisme). PHP, principalement connu pour son modèle d'exécution synchrone, a évolué pour prendre en charge ces paradigmes grâce à diverses techniques.

Modèle d'exécution standard de PHP

PHP suit traditionnellement un modèle d'exécution synchrone, en particulier lorsqu'il est utilisé avec Apache dans une configuration de serveur Web typique. Dans ce modèle, chaque requête HTTP est gérée par un seul processus PHP. Les étapes impliquées dans le traitement d'une demande comprennent :

1. Apache reçoit une requête HTTP et la transmet à PHP.
2. PHP exécute le script du début à la fin dans un seul thread.
3. PHP renvoie le résultat à Apache, qui renvoie ensuite la réponse au client.

Ce modèle garantit simplicité et facilité de compréhension mais peut devenir inefficace pour les tâches nécessitant une exécution parallèle ou la gestion de plusieurs tâches simultanément.

Evolution de la concurrence et du parallélisme en PHP

À mesure que les applications Web devenaient plus complexes, le besoin d'exécution simultanée et parallèle en PHP s'est accru. Explorons les techniques proposées par PHP pour réaliser ces paradigmes.

1. Code synchrone

Le code synchrone est la forme d'exécution la plus simple où les tâches sont exécutées les unes après les autres.

echo "Synchronous Code Example:\n";
function synchronousFunction() {
    for ($i = 0; $i < 3; $i++) {
        echo "Synchronous Loop Iteration: $i\n";
        sleep(1);
    }
}
synchronousFunction();

Dans cet exemple, chaque itération de la boucle s'exécute séquentiellement, avec un délai d'une seconde entre les itérations. Cette approche est simple mais inefficace pour les tâches liées aux E/S ou gourmandes en CPU qui pourraient bénéficier d'une exécution parallèle.

2. Créer un processus

Forking crée un nouveau processus (enfant) qui s'exécute en même temps que le processus d'origine (parent). Ceci est utile pour paralléliser les tâches.

echo "\nForking Process Example:\n";
function forkProcess() {
    $pid = pcntl_fork();
    if ($pid == -1) {
        die('could not fork');
    } else if ($pid) {
        echo "Parent Process: PID $pid\n";
        pcntl_wait($status); // Protect against Zombie children
    } else {
        echo "Child Process: Hello from the child process!\n";
        exit(0);
    }
}
forkProcess();

Dans ce code, pcntl_fork() crée un processus enfant. Les processus parent et enfant s'exécutent simultanément, permettant l'exécution de tâches en parallèle. Le processus parent attend la fin du processus enfant pour éviter de créer des processus zombies.

3. Enfilage

Les capacités de threading de PHP sont disponibles via des extensions telles que pthreads. Les threads sont plus légers que les processus et partagent le même espace mémoire, ce qui les rend adaptés aux tâches nécessitant des données partagées.

if (!class_exists('Thread')) {
    die("Threads are not supported in this PHP build\n");
}

echo "\nThreading Example:\n";
class MyThread extends Thread {
    public function run() {
        for ($i = 0; $i < 3; $i++) {
            echo "Thread Loop Iteration: $i\n";
            sleep(1);
        }
    }
}

$thread = new MyThread();
$thread->start();
$thread->join();

Cet exemple définit une classe MyThread étendant Thread. La méthode run est exécutée dans un nouveau thread, s'exécutant simultanément avec le thread principal. Cette approche est utile pour les opérations liées aux E/S où les threads peuvent gérer l'attente des ressources.

4. Générateurs

Les générateurs fournissent un moyen d'implémenter des co-routines simples, permettant aux fonctions de produire des résultats de manière itérative sans bloquer l'ensemble du programme.

echo "\nGenerators Example:\n";
function simpleGenerator() {
    yield 'First';
    yield 'Second';
    yield 'Third';
}

$gen = simpleGenerator();
foreach ($gen as $value) {
    echo "Generator Yielded: $value\n";
}

Les générateurs utilisent le mot-clé rendement pour produire des valeurs une par une, permettant ainsi à la fonction d'être suspendue et reprise, facilitant ainsi une forme de multitâche coopératif.

PHP a parcouru un long chemin depuis ses racines synchrones pour prendre en charge diverses formes de concurrence et de parallélisme. Bien que le code synchrone reste simple et efficace dans de nombreux cas d'utilisation, des techniques telles que les processus de fork, le threading et l'utilisation de générateurs ouvrent de nouvelles possibilités pour gérer efficacement des tâches complexes et parallélisables.

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!