Programmation asynchrone en PHP : guide complet

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction à la programmation asynchrone en PHP

Traditionnellement, PHP est considéré comme un langage synchrone : chaque requête est exécutée séquentiellement, bloquant l'exécution jusqu'à la fin d'une opération d'entrée-sortie (par exemple, la lecture d'un fichier ou une requête à une base de données). Cependant, avec la popularité croissante des applications web à forte charge et des microservices, le besoin de traiter des dizaines de milliers de connexions simultanées sans augmenter le nombre de processus est apparu. La programmation asynchrone résout ce problème en permettant d'exécuter des opérations de manière concurrente au sein d'un seul thread.

Dans ce guide, nous allons voir comment fonctionne l'asynchrone en PHP, quels outils sont disponibles et comment construire correctement des applications non bloquantes. Vous découvrirez les générateurs, les coroutines, les bibliothèques ReactPHP, Amp et Swoole, ainsi que la nouvelle extension Fibers.

Fondamentaux de l'asynchrone : Event Loop et entrées-sorties non bloquantes

La programmation asynchrone repose sur le concept d'Event Loop (boucle d'événements). Il s'agit d'une boucle infinie qui attend et traite les événements : requêtes réseau, fin d'opérations d'entrée-sortie, temporisateurs. Au lieu d'attendre la fin d'une opération, le code enregistre un callback qui est exécuté lorsque les données sont prêtes. Cela permet de ne pas gaspiller de temps processeur à attendre.

PHP utilise traditionnellement des fonctions bloquantes (par exemple, file_get_contents() ou sleep()). Pour un fonctionnement asynchrone, il faut les remplacer par des équivalents non bloquants. Voici un exemple simple utilisant la bibliothèque ReactPHP :

<?phprequire 'vendor/autoload.php';

use React\\EventLoop\\Factory;use React\\Promise\\Promise;

$loop = Factory::create();

// Lecture asynchrone d'un fichier$promise = new Promise(function ($resolve, $reject) use ($loop) {    $loop->addTimer(0.001, function () use ($resolve) {        $content = file_get_contents('/etc/hosts');        $resolve($content);    });});

$promise->then(function ($data) {    echo "Lu : " . strlen($data) . " octets";});

echo "Ce code s'exécutera immédiatement, sans attendre la lecture du fichier";$loop->run();?>

Dans cet exemple, addTimer enregistre une tâche qui sera exécutée lors du prochain tick de la boucle. L'Event Loop n'est pas bloquée, et nous voyons le message immédiatement, tandis que le résultat de la lecture apparaît plus tard.

Générateurs et coroutines : gestion du flux d'exécution

Les générateurs (yield) sont apparus en PHP 5.5 et permettent de suspendre l'exécution d'une fonction, en retournant des valeurs intermédiaires. Ils servent de base aux coroutines — des threads légers qui peuvent volontairement céder la main. Combinés à l'Event Loop, les générateurs permettent d'écrire un code qui ressemble à du code synchrone, mais qui s'exécute de manière asynchrone.

Regardons un exemple avec la bibliothèque Amp, qui utilise les coroutines :

<?phprequire 'vendor/autoload.php';

use Amp\\Loop;use Amp\\Delayed;

// Coroutine asynchrone$coroutine = function () {    echo "Début de la coroutine";    // On se suspend pendant 1 seconde sans bloquer    yield new Delayed(1000);    echo "1 seconde s'est écoulée";    yield new Delayed(500);    echo "Encore 0.5 seconde s'est écoulée";};

Loop::run(function () use ($coroutine) {    // On lance la coroutine    $result = yield from $coroutine();    echo "Coroutine terminée";});?>

Dans ce code, yield new Delayed(1000) suspend l'exécution de la coroutine, en redonnant la main à l'Event Loop. Après 1 seconde, l'exécution reprend exactement là où elle s'était arrêtée. Cela permet de traiter des milliers de telles coroutines simultanément, sans créer de nouveaux processus.