Why PHP Async IO Is Gaining Momentum and What It Means for PHP 9

Recent PHP Async I/O RFC Proposals

The PHP core community has introduced several RFCs targeting asynchronous I/O, including the Polling API (https://wiki.php.net/rfc/poll_api) and True Async (https://wiki.php.net/rfc/true_async), as well as a broader initiative to evolve PHP streams for better performance and security.

The Polling API aims to bring epoll/kqueue‑style event loops into PHP, enabling massive concurrent handle polling. The True Async proposal is more aggressive, seeking to embed the Swoole coroutine model directly into the language and even referencing the Swoole project within the RFC itself.

Why PHP 9 Will Focus on Async I/O

Developers increasingly recognize that asynchronous I/O is far more critical to modern PHP applications than multithreading or JIT. The article explains the reasons behind this shift and why PHP 9’s core is expected to revolve around robust async support.

Database Interaction in Traditional PHP Stacks

Most web applications rely heavily on databases such as MySQL, accessed through ORM components in frameworks like Laravel and Symfony. Typical SQL queries complete in milliseconds, allowing PHP‑FPM deployments with hundreds of workers to achieve high QPS when paired with caching, load‑balancing, and message‑queue systems (Nginx, Redis, ElasticSearch, RabbitMQ, Kafka, etc.).

However, as web architectures evolve toward micro‑services, RPC, HTTP APIs, and AI model calls, the synchronous blocking model of PHP‑FPM struggles to handle long‑running or high‑latency requests, causing QPS to drop dramatically.

Async I/O Support in Other Languages

Languages such as Go, Node.js, Python, Java, C#, and modern C++ have long provided native async I/O primitives (goroutines, promises, async/await, NIO, virtual threads, stackless coroutines). By contrast, core PHP lacks built‑in async I/O, and most PHP frameworks (Laravel, Symfony) remain synchronous.

Async Capabilities of Popular Web Frameworks

Today’s mainstream web frameworks—Express.js, Spring Boot, FastAPI, ASP.NET Core, Gin, NestJS—generally offer full async I/O support, with varying performance, learning curves, and ecosystem maturity.

Current State of PHP Async I/O

PHP itself provides no native async I/O API; its web frameworks are built on blocking models. The Swoole extension is the primary solution, offering coroutine‑based async programming without redefining the PHP API. Swoole converts existing synchronous functions into non‑blocking operations via a coroutine scheduler, allowing developers to keep familiar PHP code while gaining concurrency.

Swoole + OpenAI Async Example

The following Swoole server demonstrates how to handle streaming responses from the OpenAI API using coroutines, enabling multiple concurrent HTTP requests without blocking the main process.

use Swoole\Coroutine\Http\Client;
use Swoole\Http\Response;
use Swoole\Http\Request;
use Swoole\Coroutine;

$http = new Swoole\Http\Server("0.0.0.0", 9501);

$http->on('request', function (Request $req, Response $resp) use ($http) {
    if ($req->server['request_uri'] == '/stream') {
        $resp->header("Content-Type", "text/event-stream");
        $resp->header("Cache-Control", "no-cache");
        $resp->header("Connection", "keep-alive");
        $resp->header("X-Accel-Buffering", "no");
        $resp->header('Content-Encoding', '');
        $resp->header("Content-Length", '');

        $client = new Client('api.openai.com', 443, true);
        $client->setHeaders([
            'Authorization' => 'Bearer YOUR_API_KEY',
            'Content-Type' => 'application/json',
        ]);
        $data = json_encode([
            'model' => 'gpt-4',
            'messages' => [
                ['role' => 'user', 'content' => 'Hello, how are you?'],
            ],
        ]);
        $client->set([
            'write_func' => function ($client, $data) use ($resp) {
                $resp->write($data);
                return true;
            }
        ]);
        $client->post('/v1/chat/completions', $data);
    }
});

$http->start();

Hyperf Framework Overview

Hyperf is a high‑performance, coroutine‑based PHP micro‑service framework built on Swoole. It leverages Swoole’s async I/O capabilities and offers components such as routing, controllers, dependency injection, events, and middleware, mirroring the developer experience of Laravel while delivering superior concurrency.

Official site: https://www.hyperf.io/

Future Outlook for PHP Async I/O

As demand for async operations grows—driven by AI model calls, external APIs, and high‑latency services—the PHP core team is actively discussing and implementing native async I/O features. These enhancements aim to make asynchronous programming a first‑class capability in future PHP releases, revitalizing PHP’s role in modern web development.