Swoole en async PHP in productie draaien klinkt voor veel developers nog als experimenteel terrein, maar in 2026 is het een volwassen keuze voor high-performance applicaties. Waar traditionele PHP via FPM elk request een volledige bootstrap doorloopt, houdt Swoole processen continu in het geheugen en verwerkt het requests asynchroon via coroutines.
Dat levert forse winst op: latencies in microseconden, duizenden concurrent connecties en native support voor WebSockets. Maar het vraagt ook een andere manier van denken over je code. In dit artikel leer je hoe Swoole werkt, wanneer je het inzet en welke valkuilen je in productie tegenkomt.
Wat is Swoole?
Swoole is een PHP-extensie geschreven in C die PHP transformeert van een request-response taal naar een asynchrone runtime. De extensie voegt een event loop, coroutines, timers en native netwerk-servers toe aan PHP.
Met Swoole kun je een HTTP-server, WebSocket-server of TCP-server direct in PHP schrijven. Die server blijft draaien als een long-running proces en bedient requests zonder elke keer de framework-bootstrap te herhalen.
Dat is fundamenteel anders dan de klassieke PHP-FPM workflow die we behandelen in PHP in high-performance systemen. FPM start per request een worker die na afloop wordt opgeruimd. Swoole houdt alles warm.
Coroutines: de kern van async PHP
Het krachtigste onderdeel van Swoole zijn coroutines. Een coroutine is een lichtgewicht taak die kan pauzeren tijdens I/O-operaties, zodat andere taken in dezelfde worker kunnen doorgaan.
use Swoole\Coroutine;
use function Swoole\Coroutine\run;
run(function () {
Coroutine::create(function () {
$result = file_get_contents('https://api.example.com/users');
echo "Users opgehaald\n";
});
Coroutine::create(function () {
$result = file_get_contents('https://api.example.com/orders');
echo "Orders opgehaald\n";
});
});
Beide file_get_contents-calls draaien parallel. Zonder coroutines zou PHP blocking wachten op de eerste call voordat de tweede start. Swoole hookt systeemfuncties zoals file_get_contents, PDO en curl automatisch, zodat ze async worden zonder dat je je code hoeft te herschrijven.
Dit verschilt van de aanpak met asynchrone taken en queues, waar je werk offload naar externe workers. Met Swoole gebeurt async verwerking binnen hetzelfde proces.
Een eenvoudige HTTP-server met Swoole
Zo ziet een productie-achtige HTTP-server in Swoole eruit:
use Swoole\Http\Server;
use Swoole\Http\Request;
use Swoole\Http\Response;
$server = new Server('0.0.0.0', 9501);
$server->set([
'worker_num' => 4,
'max_request' => 10000,
'enable_coroutine' => true,
]);
$server->on('request', function (Request $request, Response $response) {
$response->header('Content-Type', 'application/json');
$response->end(json_encode(['status' => 'ok']));
});
$server->start();
Je start dit script via de CLI en het proces blijft draaien. Nginx of een reverse proxy stuurt requests door naar poort 9501.
De worker_num instelling bepaalt hoeveel worker-processen er draaien. Elke worker kan met coroutines duizenden concurrent connecties afhandelen, waar een FPM-worker er maar één tegelijk doet.
Frameworks op Swoole: Laravel Octane en RoadRunner
De meeste developers gebruiken Swoole niet rechtstreeks, maar via frameworks. Laravel Octane is de bekendste optie voor Laravel-projecten.
composer require laravel/octane
php artisan octane:install --server=swoole
php artisan octane:start --workers=4 --max-requests=500
Octane houdt je Laravel-applicatie in het geheugen. De service container, routes, views en configuratie worden één keer geladen en vervolgens hergebruikt over duizenden requests. Dit kan je response times verkorten van 100ms naar 10ms of minder.
Symfony heeft een vergelijkbare aanpak via de Symfony Runtime component. Wil je meer weten over beide frameworks, lees dan Symfony vs Laravel: wanneer kies je welke?.
De belangrijkste valkuilen in productie
Swoole is krachtig, maar de long-running aard introduceert problemen die je in FPM nooit tegenkomt. Hieronder de belangrijkste.
Memory leaks
In FPM wordt het geheugen na elk request vrijgegeven. In Swoole blijft een worker uren of dagen draaien. Een kleine leak, bijvoorbeeld een statische array die groeit, vreet uiteindelijk al je RAM op.
Oplossing: gebruik max_request om workers periodiek te recyclen. Profiling met Blackfire of Tideways helpt leaks opsporen voordat ze kritiek worden.
Globale state en singletons
Singleton-patterns uit design patterns in PHP gedragen zich anders in Swoole. Wat in FPM per-request state was, wordt in Swoole gedeeld tussen requests binnen dezelfde worker.
Een ingelogde gebruiker uit request A kan zo lekken naar request B. Octane lost dit op met automatische state-resets, maar eigen code moet je zelf controleren.
Database connecties
Een PDO-connectie openen bij elke request is verspilling in Swoole. Gebruik connection pools zodat connecties hergebruikt worden tussen coroutines. Swoole biedt hiervoor Swoole\Database\PDOPool.
Let op: één connectie mag niet gedeeld worden tussen gelijktijdige coroutines. Gebruik altijd een pool die connecties uitleent en teruggeeft. Voor veilig databasegebruik in het algemeen is werken met databases in PHP met PDO een goede basis.
Incompatibele libraries
Niet alle PHP-libraries zijn Swoole-safe. Libraries die blocking I/O doen buiten de gehookte functies, of die interne state bijhouden, kunnen je hele worker blokkeren.
Check altijd de documentatie van externe packages voordat je ze in een Swoole-context gebruikt.
Deployment en process management
Een Swoole-applicatie is een daemon, geen script. Je hebt iets nodig dat het proces beheert, herstart bij crashes en bij deployments gracieus herlaadt.
Populaire opties:
- Supervisor: klassiek en betrouwbaar voor PHP-processen.
- systemd: prima voor moderne Linux-servers.
- Docker + Kubernetes: steeds gebruikelijker, met liveness/readiness probes.
Voor zero-downtime deploys stuur je een SIGUSR1-signaal naar Swoole om workers te reloaden. Het master-proces blijft luisteren terwijl oude workers hun requests afmaken en nieuwe workers de nieuwe code laden.
Wil je dit integreren in je deployment pipeline, bekijk dan CI/CD pipelines voor PHP projecten.
Wanneer kies je voor Swoole?
Swoole is geen vervanging voor elke PHP-applicatie. Kies het wanneer:
- Je real-time features nodig hebt (WebSockets, chat, live dashboards).
- Je extreme concurrency moet ondersteunen (10k+ gelijktijdige connecties).
- Latency kritiek is (trading, gaming, ad-tech).
- Je bestaande Laravel of Symfony applicatie sneller moet zonder herbouw (via Octane).
Voor een standaard MKB-website, WordPress of simpele API voegt Swoole vooral operationele complexiteit toe zonder duidelijke winst. Daar is FPM met goede caching, zie caching in PHP, meestal de betere keuze.
Swoole vs andere async-oplossingen
Swoole is niet de enige async-oplossing in PHP-land:
- ReactPHP: pure PHP, werkt zonder extensie, gebruikt promises. Makkelijker te installeren, maar trager.
- AMPHP: pure PHP met native fibers sinds PHP 8.1, moderne API, goede library support.
- RoadRunner: application server geschreven in Go, draait PHP-workers. Makkelijker deploybaar dan Swoole, minder features.
- FrankenPHP: nieuwe speler gebaseerd op Caddy, ondersteunt worker mode en async I/O.
De keuze hangt af van je stack en team. Swoole geeft de hoogste performance maar ook de steilste leercurve. RoadRunner en FrankenPHP zijn toegankelijker voor teams die Octane-achtige voordelen willen zonder C-extensie.
Monitoring en debugging
Long-running processen vragen om andere monitoring dan FPM. Minimaal wil je:
- Memory usage per worker, detecteert leaks vroeg.
- Request throughput en latency, zichtbaar via Prometheus of New Relic.
- Coroutine counts, te veel actieve coroutines duidt op blocking code.
- Worker restarts, frequente restarts wijzen op crashes of memory limits.
Debugging is lastiger dan bij FPM omdat je geen verse request-context hebt. Goede logging, structured logs en tracing (OpenTelemetry) zijn essentieel. Zie ook de officiële Swoole documentatie voor productie-best-practices.
Veelgestelde vragen
Wat is Swoole precies?
Swoole is een PHP-extensie die asynchrone I/O, coroutines en long-running processen mogelijk maakt. Hiermee kun je in PHP servers, workers en real-time applicaties bouwen zonder traditionele FPM-request-response cyclus.
Is Swoole klaar voor productie?
Ja, Swoole draait al jaren in productie bij grote bedrijven, vooral in Azië. Het vereist wel extra aandacht voor memory leaks, globale state en deployment, omdat processen lang blijven draaien.
Wat is het verschil tussen Swoole en ReactPHP?
Swoole is een C-extensie met native coroutines en hogere performance. ReactPHP is pure PHP met een event loop en werkt zonder extensie, maar is trager en gebruikt promises in plaats van coroutines.
Kan ik Laravel of Symfony met Swoole draaien?
Ja, via Laravel Octane of Symfony Runtime kun je beide frameworks op Swoole draaien. Dit geeft forse performance-winst, maar vraagt wel om code die stateless is en geen memory leaks veroorzaakt.
Wanneer moet je Swoole NIET gebruiken?
Vermijd Swoole voor kleine projecten, simpele CRUD-apps of teams zonder ervaring met long-running processen. De operationele complexiteit weegt dan niet op tegen de performance-winst.