$urls = ['amazon.com', 'ebay.com', 'allegro.pl'];

foreach ($urls as $url) {
    $content = file_get_contents(
        sprintf('http://%s', $url)
    );
}

amazon.com:    1.3739
ebay.com:      1.4950
allegro.pl:    0.4184

Total time:    3.2877

L1 cache reference ......................... 0.5 ns
Branch mispredict ............................ 5 ns
L2 cache reference ........................... 7 ns
Mutex lock/unlock ........................... 25 ns
Main memory reference ...................... 100 ns             
Compress 1K bytes with Zippy ............. 3,000 ns  =   3 µs
Send 2K bytes over 1 Gbps network ....... 20,000 ns  =  20 µs
SSD random read ........................ 150,000 ns  = 150 µs
Read 1 MB sequentially from memory ..... 250,000 ns  = 250 µs
Round trip within same datacenter ...... 500,000 ns  = 0.5 ms
Read 1 MB sequentially from SSD* ..... 1,000,000 ns  =   1 ms
Disk seek ........................... 10,000,000 ns  =  10 ms
Read 1 MB sequentially from disk .... 20,000,000 ns  =  20 ms
Send packet CA->Netherlands->CA .... 150,000,000 ns  = 150 ms

var http = require('http');
var urls = ['amazon.com', 'ebay.com', 'allegro.pl'];

for (let i in urls) {
    http.get('http://' + urls[i], function(response){
        var str = '';
        response.on('data', function(chunk) {
            str += chunk;
        });
        response.on('end', function(){});
    });
}

allegro.pl:   0.3901
amazon.com:   0.4755
ebay.com:     0.6653

Total time:   0.6756

amazon.com:    1.3739
ebay.com:      1.4950
allegro.pl:    0.4184

Total time:    3.2877

SELECT(2)                                    Linux Programmer's Manual                          

NAME
       select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - synchronous I/O multiplexing

SYNOPSIS
       /* According to POSIX.1-2001, POSIX.1-2008 */
       #include <sys/select.h>

       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);

       int pselect(int nfds, fd_set *readfds, fd_set *writefds,
                   fd_set *exceptfds, const struct timespec *timeout,
                   const sigset_t *sigmask);

DESCRIPTION
       select()  and  pselect()  allow a program to monitor multiple file descriptors, 
       waiting until one or more of the file descriptors become "ready" for some class
       of I/O operation (e.g., input possible).  A file descriptor  is  considered  
       ready if it is possible to perform a corresponding I/O operation (e.g., read(2) 
       without blocking, or a sufficiently small write(2)).

<?php

$readable = [stream_socket_client(), stream_socket_client()];
$writable = $writeStreams;
$except = [];

while(true) {
    if (stream_select($readable, $writable, $except, 1)) {
        foreach ($readable as $stream) {
    
        }
        foreach ($writable as $stream) {
    
        }
    }
}

$emitter = new Evenement\EventEmitter();

$emitter->on('data', function ($data) {
    echo $data;
});

$emitter->emit('data', [$data]);

$loop = React\EventLoop\Factory::create();

$server = stream_socket_server('tcp://127.0.0.1:8080');
stream_set_blocking($server, 0);

$loop->addReadStream($server, function ($server) use ($loop) {
    $conn = stream_socket_accept($server);

    $loop->addWriteStream($conn, function ($conn)  {

    });
});

$loop->addPeriodicTimer(5, function () {
    $memory = memory_get_usage() / 1024;
    $formatted = number_format($memory, 3).'K';
    echo "Current memory usage: {$formatted}\n";
});

$loop->run();

interface ReadableStreamInterface
{
    public function isReadable();
    public function pause();
    public function resume();
    public function close();
    public function pipe(WritableStreamInterface $dest, array $options = array());
}
Events: data, error, end, close

interface WritableStreamInterface
{
    public function isWritable();
    public function write($data);
    public function end($data = null);
    public function close();
}
Events: drain, error, close, pipe

use React\EventLoop\Factory;
use React\Stream\ReadableResourceStream;
use React\Stream\WritableResourceStream;

$loop = Factory::create();

$source = new ReadableResourceStream(
    fopen('omg.txt', 'r'), $loop
);
$dest = new WritableResourceStream(
    fopen('wtf.txt', 'w'), $loop
);

$source->pipe($dest);

$loop->run();

$loop = React\EventLoop\Factory::create();

$socket = new React\Socket\Server(8080, $loop);
$socket->on('connection', function (ConnectionInterface $conn) {
    $conn->write("Hello " . $conn->getRemoteAddress() . "!\n");
    $conn->write("Welcome to this amazing server!\n");
    $conn->write("Here's a tip: don't say anything.\n");

    $conn->on('data', function ($data) use ($conn) {
        $conn->close();
    });
});

$loop->run();

$loop = \React\EventLoop\Factory::create();
$factory = new \React\Dns\Resolver\Factory();
$dns = $factory->create('8.8.8.8', $loop);

$dns->resolve($argv[1])
    ->then(
        function ($ip) { echo "Host: $ip\n"; },
        function ($error) { echo "Error: {$error->getMessage()}\n"; }
    );

$loop->run();

php bin/promise.php 4developers.pl
Host: 87.98.239.5

php bin/promise.php aaa           
Error: DNS Request did not return valid answer.

$loop = React\EventLoop\Factory::create();

$process = new React\ChildProcess\Process('echo foo');
$process->start($loop);

$process->stdout->on('data', function ($chunk) {
    echo $chunk;
});

$process->on('exit', function($exitCode, $termSignal) {
    echo 'Process exited with code ' . $exitCode . PHP_EOL;
});

$loop->run();

$drone->on('landed', function() {
    // do something
});

$drone
    ->after(3, function () use ($drone) {
        $drone->up(0.6);
    })
    ->after(4, function () use ($drone) {
        $drone->stop();
    })
    ->after(1, function () use ($drone) {
        $drone->left(0.3);
    })

$drone->start();

function slowAddition($x, $y) {
    sleep(1);
    return $x + $y;
}

$dispatcher = new Amp\Thread\Dispatcher;

$a = $dispatcher->call('slowAddition', 1, 5);
$b = $dispatcher->call('slowAddition', 10, 10);
$c = $dispatcher->call('slowAddition', 11, 31);

$comboPromise = Amp\all([$a, $b, $c]);

list($a, $b, $c) = $comboPromise->wait();