Concurrence et multithreading en PHP : niveau avancé

Concurrence et multithreading en PHP : niveau avancé

PHP est traditionnellement associé à l'exécution synchrone de scripts, mais les applications web modernes nécessitent le traitement de multiples tâches simultanément. La concurrence (concurrency) et le multithreading (multithreading) permettent d'augmenter considérablement les performances, d'accélérer le traitement des requêtes et d'utiliser efficacement les ressources du serveur. Dans cet article, nous examinerons les techniques avancées de travail avec le multithreading en PHP, y compris l'extension pthreads, les processus parallèles, les appels asynchrones et la gestion des threads.

1. Bases du multithreading en PHP : l'extension pthreads

L'extension pthreads est l'outil principal pour travailler avec les threads en PHP. Elle permet de créer, lancer et synchroniser plusieurs threads d'exécution au sein d'un même processus. Important : pthreads fonctionne uniquement en mode CLI et nécessite une compilation de PHP avec le support des threads (ZTS — Zend Thread Safety).

Exemple de création d'un thread simple :

<?phpclass WorkerThread extends Thread {    private $id;        public function __construct($id) {        $this->id = $id;    }        public function run() {        echo "Thread {$this->id} démarré";        sleep(2);        echo "Thread {$this->id} terminé";    }}

$threads = [];for ($i = 1; $i <= 5; $i++) {    $threads[$i] = new WorkerThread($i);    $threads[$i]->start();}

foreach ($threads as $thread) {    $thread->join();}?>

La méthode start() lance le thread, et join() attend sa fin. Sans join(), le thread principal peut se terminer avant les threads enfants.

2. Synchronisation des threads et ressources partagées

Lors du travail avec le multithreading, il est essentiel de synchroniser l'accès aux données communes. PHP fournit plusieurs mécanismes : les objets Mutex, Volatile et Threaded.

Mutex (exclusion mutuelle) — bloque l'accès à une ressource pour les autres threads pendant qu'un thread travaille avec elle.

<?phpclass Counter extends Threaded {    private $count = 0;        public function increment() {        $this->synchronized(function() {            $this->count++;        });    }        public function getCount() {        return $this->count;    }}

class IncrementThread extends Thread {    private $counter;        public function __construct(Counter $counter) {        $this->counter = $counter;    }        public function run() {        for ($i = 0; $i < 1000; $i++) {            $this->counter->increment();        }    }}

$counter = new Counter();$threads = [];

for ($i = 0; $i < 10; $i++) {    $threads[$i] = new IncrementThread($counter);    $threads[$i]->start();}

foreach ($threads as $thread) {    $thread->join();}

echo "Valeur finale : " . $counter->getCount(); // 10000?>

Volatile — garantit que les modifications d'une variable seront visibles par tous les threads. Utilisez Volatile pour les types de données simples.

$sharedFlag = new Volatile();$sharedFlag->flag = false;

// Dans un thread$sharedFlag->flag = true;

// Dans un autre threadif ($sharedFlag->flag) {    echo "Drapeau défini";}

3. Processus parallèles et tâches asynchrones

Si l'extension pthreads n'est pas disponible (par exemple, sur un hébergement mutualisé), on peut utiliser des processus parallèles via pcntl_fork() ou des bibliothèques asynchrones comme ReactPHP ou Amp.

pcntl_fork() — crée un processus enfant qui s'exécute en parallèle avec le processus parent.

<?php$pid = pcntl_fork();if ($pid == -1) {    die("Impossible de créer le processus");} elseif ($pid)