1# Async PHP Patterns
2 
3## Swoole HTTP Server
4 
5```php
6<?php
7 
8declare(strict_types=1);
9 
10use Swoole\HTTP\Server;
11use Swoole\HTTP\Request;
12use Swoole\HTTP\Response;
13 
14$server = new Server('0.0.0.0', 9501);
15 
16$server->set([
17    'worker_num' => 4,
18    'max_request' => 10000,
19    'task_worker_num' => 2,
20    'enable_coroutine' => true,
21]);
22 
23$server->on('start', function (Server $server) {
24    echo "Swoole HTTP server started at http://0.0.0.0:9501\n";
25});
26 
27$server->on('request', function (Request $request, Response $response) {
28    $response->header('Content-Type', 'application/json');
29 
30    match ($request->server['request_uri']) {
31        '/api/users' => handleUsers($request, $response),
32        '/api/health' => $response->end(json_encode(['status' => 'healthy'])),
33        default => $response->status(404)->end(json_encode(['error' => 'Not found'])),
34    };
35});
36 
37function handleUsers(Request $request, Response $response): void
38{
39    // Coroutine for concurrent DB queries
40    go(function () use ($response) {
41        $users = queryDatabase('SELECT * FROM users LIMIT 10');
42        $response->end(json_encode(['data' => $users]));
43    });
44}
45 
46$server->start();
47```
48 
49## Swoole Coroutines
50 
51```php
52<?php
53 
54declare(strict_types=1);
55 
56use Swoole\Coroutine;
57use Swoole\Coroutine\Http\Client;
58 
59// Concurrent HTTP requests
60Coroutine\run(function () {
61    $results = [];
62 
63    // Create multiple coroutines
64    $wg = new Coroutine\WaitGroup();
65 
66    $urls = [
67        'https://api.example.com/users',
68        'https://api.example.com/posts',
69        'https://api.example.com/comments',
70    ];
71 
72    foreach ($urls as $url) {
73        $wg->add();
74        go(function () use ($url, &$results, $wg) {
75            $client = new Client(parse_url($url, PHP_URL_HOST), 443, true);
76            $client->set(['timeout' => 5]);
77            $client->get(parse_url($url, PHP_URL_PATH));
78 
79            $results[$url] = [
80                'status' => $client->statusCode,
81                'body' => $client->body,
82            ];
83 
84            $client->close();
85            $wg->done();
86        });
87    }
88 
89    $wg->wait();
90 
91    print_r($results);
92});
93```
94 
95## Swoole Async MySQL
96 
97```php
98<?php
99 
100declare(strict_types=1);
101 
102use Swoole\Coroutine;
103use Swoole\Coroutine\MySQL;
104 
105Coroutine\run(function () {
106    $mysql = new MySQL();
107 
108    $connected = $mysql->connect([
109        'host' => '127.0.0.1',
110        'port' => 3306,
111        'user' => 'root',
112        'password' => 'password',
113        'database' => 'test',
114    ]);
115 
116    if (!$connected) {
117        throw new \RuntimeException($mysql->connect_error);
118    }
119 
120    // Async query
121    $result = $mysql->query('SELECT * FROM users WHERE active = 1');
122 
123    foreach ($result as $row) {
124        echo "User: {$row['name']}\n";
125    }
126 
127    // Prepared statements
128    $stmt = $mysql->prepare('SELECT * FROM users WHERE id = ?');
129    $stmt->execute([42]);
130    $user = $stmt->fetchAll();
131 
132    $mysql->close();
133});
134```
135 
136## Swoole Channel (Communication)
137 
138```php
139<?php
140 
141declare(strict_types=1);
142 
143use Swoole\Coroutine;
144use Swoole\Coroutine\Channel;
145 
146Coroutine\run(function () {
147    $channel = new Channel(10); // Buffer size: 10
148 
149    // Producer
150    go(function () use ($channel) {
151        for ($i = 1; $i <= 5; $i++) {
152            $channel->push("Task {$i}");
153            echo "Produced: Task {$i}\n";
154            Coroutine::sleep(0.5);
155        }
156        $channel->close();
157    });
158 
159    // Consumer
160    go(function () use ($channel) {
161        while (true) {
162            $task = $channel->pop();
163            if ($task === false && $channel->errCode === SWOOLE_CHANNEL_CLOSED) {
164                break;
165            }
166            echo "Consumed: {$task}\n";
167            Coroutine::sleep(1);
168        }
169    });
170});
171```
172 
173## ReactPHP Event Loop
174 
175```php
176<?php
177 
178declare(strict_types=1);
179 
180require 'vendor/autoload.php';
181 
182use React\EventLoop\Loop;
183use React\Http\Message\Response;
184use Psr\Http\Message\ServerRequestInterface;
185 
186// HTTP Server
187$server = new React\Http\HttpServer(function (ServerRequestInterface $request) {
188    return new Response(
189        200,
190        ['Content-Type' => 'application/json'],
191        json_encode([
192            'method' => $request->getMethod(),
193            'uri' => (string) $request->getUri(),
194            'timestamp' => time(),
195        ])
196    );
197});
198 
199$socket = new React\Socket\SocketServer('0.0.0.0:8080');
200$server->listen($socket);
201 
202echo "Server running at http://0.0.0.0:8080\n";
203 
204// Periodic timer
205Loop::addPeriodicTimer(5.0, function () {
206    echo "Heartbeat: " . date('H:i:s') . "\n";
207});
208 
209// One-time timer
210Loop::addTimer(10.0, function () {
211    echo "This runs once after 10 seconds\n";
212});
213```
214 
215## ReactPHP Async MySQL
216 
217```php
218<?php
219 
220declare(strict_types=1);
221 
222require 'vendor/autoload.php';
223 
224use React\MySQL\Factory;
225use React\MySQL\QueryResult;
226 
227$factory = new Factory();
228 
229$connection = $factory->createLazyConnection('root:password@localhost/database');
230 
231$connection->query('SELECT * FROM users WHERE active = 1')
232    ->then(
233        function (QueryResult $result) {
234            echo "Found " . count($result->resultRows) . " users\n";
235            foreach ($result->resultRows as $row) {
236                echo "User: {$row['name']}\n";
237            }
238        },
239        function (\Exception $error) {
240            echo "Error: " . $error->getMessage() . "\n";
241        }
242    );
243 
244// Prepared statements
245$connection->query('SELECT * FROM users WHERE id = ?', [42])
246    ->then(function (QueryResult $result) {
247        $user = $result->resultRows[0] ?? null;
248        var_dump($user);
249    });
250```
251 
252## ReactPHP Promises
253 
254```php
255<?php
256 
257declare(strict_types=1);
258 
259use React\Promise\Promise;
260use React\Promise\Deferred;
261use function React\Promise\all;
262 
263// Creating promises
264function fetchUser(int $id): Promise
265{
266    $deferred = new Deferred();
267 
268    // Simulate async operation
269    Loop::addTimer(1.0, function () use ($deferred, $id) {
270        $deferred->resolve([
271            'id' => $id,
272            'name' => "User {$id}",
273        ]);
274    });
275 
276    return $deferred->promise();
277}
278 
279// Using promises
280fetchUser(42)
281    ->then(function ($user) {
282        echo "Got user: {$user['name']}\n";
283        return fetchUserPosts($user['id']);
284    })
285    ->then(function ($posts) {
286        echo "Got " . count($posts) . " posts\n";
287    })
288    ->catch(function (\Exception $error) {
289        echo "Error: " . $error->getMessage() . "\n";
290    });
291 
292// Parallel promises
293all([
294    fetchUser(1),
295    fetchUser(2),
296    fetchUser(3),
297])->then(function ($users) {
298    echo "Fetched " . count($users) . " users\n";
299});
300```
301 
302## PHP Fibers (Native PHP 8.1+)
303 
304```php
305<?php
306 
307declare(strict_types=1);
308 
309// Simple async function using fibers
310function async(callable $callback): Fiber
311{
312    return new Fiber($callback);
313}
314 
315function await(Fiber $fiber): mixed
316{
317    if (!$fiber->isStarted()) {
318        return $fiber->start();
319    }
320    if ($fiber->isTerminated()) {
321        return $fiber->getReturn();
322    }
323    return $fiber->resume();
324}
325 
326// Simulate async I/O
327function fetchData(string $url): Fiber
328{
329    return async(function () use ($url) {
330        echo "Fetching: {$url}\n";
331        Fiber::suspend('pending');
332 
333        // Simulate network delay
334        sleep(1);
335 
336        return "Data from {$url}";
337    });
338}
339 
340// Usage
341$fiber1 = fetchData('https://api.example.com/users');
342$fiber2 = fetchData('https://api.example.com/posts');
343 
344await($fiber1);
345await($fiber2);
346 
347$result1 = await($fiber1);
348$result2 = await($fiber2);
349 
350echo "{$result1}\n";
351echo "{$result2}\n";
352```
353 
354## Amphp Framework
355 
356```php
357<?php
358 
359declare(strict_types=1);
360 
361require 'vendor/autoload.php';
362 
363use Amp\Http\Server\HttpServer;
364use Amp\Http\Server\Request;
365use Amp\Http\Server\Response;
366use Amp\Http\Server\Router;
367use Amp\Socket\Server as SocketServer;
368use function Amp\async;
369use function Amp\Future\await;
370 
371// HTTP Server with Amphp
372$router = new Router();
373 
374$router->addRoute('GET', '/api/users', function (Request $request): Response {
375    // Concurrent database queries
376    $users = await([
377        async(fn() => queryUsers()),
378        async(fn() => queryUserStats()),
379    ]);
380 
381    return new Response(
382        status: 200,
383        headers: ['content-type' => 'application/json'],
384        body: json_encode(['users' => $users[0], 'stats' => $users[1]]),
385    );
386});
387 
388$server = new HttpServer(
389    servers: [SocketServer::listen('0.0.0.0:8080')],
390    requestHandler: $router,
391);
392 
393$server->start();
394```
395 
396## Quick Reference
397 
398| Technology | Use Case | Performance |
399|------------|----------|-------------|
400| Swoole | High-performance servers, WebSockets | Very High |
401| ReactPHP | Event-driven apps, real-time | High |
402| Amphp | Modern async framework | High |
403| Fibers | Native async (PHP 8.1+) | Medium |
404| Generators | Simple async patterns | Medium |
405 
406| Feature | Swoole | ReactPHP | Amphp |
407|---------|--------|----------|-------|
408| Coroutines | Yes | No (Promises) | Yes (Fibers) |
409| HTTP Server | Built-in | Via package | Via package |
410| WebSockets | Built-in | Via package | Via package |
411| Extension | Required | Not required | Not required |
412| Learning Curve | Medium | Low | Medium |
413