Depuis PHP 8.1 et l'arrivée des Fibers, l'async en PHP est devenu sérieusement utilisable. En 2026, voici les trois options et comment choisir.

Les Fibers (natif PHP)

Les fibers sont la primitive de bas niveau qui permet de suspendre/reprendre l'exécution. Elles ne sont pas un framework async en soi, mais la brique sur laquelle tout repose maintenant.

$fiber = new Fiber(function (): void {
    echo 'Start';
    $value = Fiber::suspend('paused');
    echo 'Resumed with ' . $value;
});

echo $fiber->start();   // "Start" puis "paused"
echo $fiber->resume('data'); // "Resumed with data"

Utile ? Pas directement. Mais c'est ce qui fait tourner les frameworks modernes.

ReactPHP : l'event loop mature

ReactPHP est là depuis 2012. En 2026 il tourne en production chez beaucoup d'équipes, notamment pour :

  • Serveurs HTTP long-running.
  • Workers qui consomment des queues Kafka/RabbitMQ.
  • Pipelines de streaming (ETL léger).
$loop = React\EventLoop\Loop::get();
$server = new React\Http\HttpServer(function ($request) {
    return React\Promise\resolve(
        new React\Http\Message\Response(200, [], 'OK')
    );
});
$server->listen(new React\Socket\SocketServer('0.0.0.0:8080', [], $loop));

Force : pur userland, portable, testable. Limite : l'écosystème packages reste niche et il faut "penser async" partout.

Swoole : la performance brute

Swoole / OpenSwoole est une extension C qui transforme PHP en runtime async-natif. Performances éblouissantes, mais c'est du PHP qui n'a plus grand-chose à voir avec le PHP classique.

  • Coroutines natives via go(function () {...}).
  • Serveur HTTP intégré.
  • Connection pooling MySQL/Redis.

Utilisé par Laravel Octane pour des perfs x5-10 vs FPM.

Co\run(function () {
    $r1 = go(fn() => fetchUser(1));
    $r2 = go(fn() => fetchOrders(1));
    $user = $r1->getResult();
    $orders = $r2->getResult();
});

Laravel Octane : le compromis

Octane encapsule Swoole ou FrankenPHP derrière une API Laravel. Vous gardez votre code familier, vous gagnez 5-10x en perf. C'est le compromis que je recommande à 80 % des équipes Laravel qui veulent de la perf sans repenser leur code.

FrankenPHP : le nouveau venu solide

FrankenPHP est écrit en Go, inclut un serveur HTTP moderne avec HTTP/3, et supporte le mode worker (app bootstrappée une fois, requêtes traitées en série rapide). Parfait avec Symfony ou Laravel.

Matrice de choix

  • App Laravel existante, besoin perf → Octane.
  • App Symfony, stack prod simple → FrankenPHP.
  • Worker queue custom, besoin I/O massif → ReactPHP.
  • Serveur temps-réel (WebSocket, game server) → Swoole pur.
  • Micro-service API classique avec FPM qui marche → ne changez rien tant que ça marche.

Les pièges partagés

  • Fuites mémoire : en mode long-running, un objet jamais libéré grandit jusqu'à crash.
  • Singletons avec état : risque de pollution entre requêtes.
  • Connections DB : pooling obligatoire, sinon explosion.
  • Tests : nouvelle complexité, mocks isolés plus durs.

Migration vers du PHP async en production ? Parlons-en.

Tags #php #async #swoole #reactphp #fibers