I've been doing some tests on ReactPHP because it looks pretty awesome. I've tested it with the following react/socket code, for a simple socket server.
$loop = React\EventLoop\Factory::create(); $socket = new React\Socket\Server($loop); $socket->on('connection', function ($conn) { echo 'New client !'; $conn->on('data', function ($data) use ($conn) { $conn->write("Wow, some data, such cool\n"); $conn->close(); }); }); $socket->listen(1337); $loop->run();
Until this point there's no problem. The server shows New client !
when a client is connected and the client receives the response.
But I done a new test, with more processing on the data
event. To illustrate my words, I'll add a for
loop that will take a few milliseconds to complete :
$conn->on('data', function ($data) use ($conn) { $conn->write("Wow, some data, such cool\n"); for ($i=0; $i<10000000; $i++); // here $conn->close(); });
In this case, with 10 clients, the client will show the text Wow, some data, such cool
after all clients processing (so ~2 seconds), but server will show New client !
without waiting.
So here my lack of understanding, ReactPHP is an asynchronous I/O, but PHP is single-threaded, and if there is a lot of processing between input and output, that will block all clients.
PHP has no built in support for asynchronous calls. You can make pseudo-asynchronous calls using curl.
ReactPHP is production ready and battle-tested with millions of installations from all kinds of projects around the world.
ReactPHP is a low-level library for event-driven programming in PHP. At its core is an event loop, on top of which it provides low-level utilities, such as: Streams abstraction, async DNS resolver, network client/server, HTTP client/server and interaction with processes.
ReactPHP is an asynchronous I/O, but PHP is single-threaded, and if there is a lot of processing between input and output, that will block all clients.
Yes.
ReactPHP is very much inspired by node.js, which follows the same principle. The goal of such event-based patterns is not to exploit your server 16 CPU's, but to exploit fully your processor by processing HTTP request B while your controller for request A, which has made request to database, is paused until the 'database request success' event is called.
Your test is going exactly against the assumption made by node.js and ReactPHP: "computation is fast, I/O are slow", so if we do computation during I/O (and not between I/O), then CPU time will always be available in higher quantity than needed.
With node.js or ReactPHP if you want to use your server 16 CPU, you just launch 16 server process on 16 port and put a load balancer like nginx in front of them.
But keep in mind ReactPHP is still experimental and not ready for production.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With