This document discusses asynchronous PHP processing and libraries. It begins with an overview of synchronous vs asynchronous processing and blocking vs non-blocking I/O. It then reviews several approaches for asynchronous PHP including Pthreads, pcntl_fork, popen, curl_multi, and event loops with libraries like ReactPHP. ReactPHP is discussed in depth as an event-driven non-blocking I/O library that uses promises and streams for asynchronous operations. Examples are provided for asynchronous HTTP requests, DNS lookups, and a pub/sub application using ZeroMQ. Key points emphasized are that asynchronous code does not necessarily run faster and execution order is not guaranteed.

1. The promise of asynchronous PHP
Wim Godden
Cu.be Solutions
@wimgtr

2. Who am I ?
Wim Godden (@wimgtr)

3. Where I'm from

4. Where I'm from

5. Where I'm from

6. Where I'm from

7. Where I'm from

8. Where I'm from

9. My town

10. My town

11. Belgium – the traffic

12. Who am I ?
Wim Godden (@wimgtr)
Founder of Cu.be Solutions (http://cu.be)
Open Source developer since 1997
Developer of PHPCompatibility, OpenX, PHPConsistent, ...
Speaker at Open Source conferences

13. Who are you ?
Developers ?
Ever worked with asynchronous PHP libraries ?
Node.JS ?

14. Synchronous processing
Insert
order
Check
payment
Update
stock
Fedex
API
Send
mail
Thank
you
page

15. Asynchronous processing
Insert
order
Check
payment
Update
stock
Fedex
API
Send
mail
Thank
you
page

16. Blocking I/O
Disk reading/writing
Network reading/writing
Communication with DB (with some exceptions)
Sending mail
...

17. Non-blocking = good
Work on multiple things at same time
Not entirely sequential anymore
How do you know something is finished ?
→ Events !

18. Events
Start
Progress update
End (successfully)
Failed

19. Callback hell
$one->do(function ($two) {
$two->do(function ($three) {
$three->do(function ($stillcounting) {
$stillcounting->get(function() {
throw new IQuitException();
});
});
});
});

20. State of asynchronous PHP
Several built-in functions
Several libraries (using the built-in functions)
Facebook Hack

21. Pthreads
PECL extension
Multithreading
Requires zts (thread-safe)

22. Pthreads
class WebRequest extends Thread {
public $url;
public $response;
public function __construct($url){
$this->url = $url;
}
public function run() {
$this->response = file_get_contents($this->url);
}
}
$request = new WebRequest("https://cu.be");
if ($request->start()) {
/* do some work here */
$a = array_fill(0, 10000000, 'test');
for ($i = 0; $i < count($a); $i++) {}
/* ensure we have data */
$request->join();
echo $request->response;
}

23. pcntl_fork
Forks PHP process
Multiprocessing, not multithreading
No communication between processes
No Apache

24. popen
child.php
<?php
/* Do some work */
echo 'Output here';
main.php
<?php
// open child process
$child = popen('php child.php', 'r');
/*
* Do some work, while already doing other
* work in the child process.
*/
// get response from child (if any) as soon at it's ready:
$response = stream_get_contents($child);
W
arning
: doesn't behave
sam
e
on
all operating
system
s
!

25. Sequential curl requests
$urls = ['http://www.google.com/', 'http://www.yahoo.com/', 'http://cu.be', 'http://www.microsoft.com/'];
$results = [];
foreach ($urls as $key => $url) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$results[$url] = curl_exec($ch);
curl_close($ch);
}

26. Asynchronous curl_multi requests
$urls = ['http://www.google.com/', 'http://www.yahoo.com/', 'http://cu.be','http://www.microsoft.com/'];
$chandles = [];
$mh = curl_multi_init();
foreach ($urls as $key => $url) {
$chandles[$key] = curl_init();
curl_setopt($chandles[$key], CURLOPT_URL, $url);
curl_setopt($chandles[$key], CURLOPT_HEADER, 0);
curl_setopt($chandles[$key], CURLOPT_RETURNTRANSFER, 1);
curl_multi_add_handle($mh, $chandles[$key]);
}
$active = null;
do {
$mrc = curl_multi_exec($mh, $active);
} while ($active > 0);
foreach ($chandles as $ch) {
$results[curl_getinfo($ch, CURLINFO_EFFECTIVE_URL)] = curl_multi_getcontent($ch);
curl_multi_remove_handle($mh, $ch);
}
curl_multi_close($mh);

27. Using Curl as async system
$c = curl_init();
curl_setopt($c, CURLOPT_URL, 'http://somewhere/sub1.php?
action=go&from=4&to=40000');
curl_setopt($c, CURLOPT_FOLLOW_LOCATION, true);
curl_setopt($c, CURLOPT_FRESH_CONNECT, true);
curl_setopt($c, CURLOPT_TIMEOUT_MS, 1);
curl_exec($c);
curl_close($c);
// Code continues after 1ms timeout
main.php
400ms
main.php
100ms
sub1.php
100ms
sub2.php
100ms
sub3.php
100ms
function1()
100ms
function2()
100ms
function3()
100ms

28. Libevent, libev, libuv
Event handling libraries
PHP extensions (most through PECL)
libevent = also used by Memcached
libev = not available on Windows

29. ReactPHP
Event-driven non-blocking I/O library
Written in PHP
Provides event-driven interface
Implements event loop

30. ReactPHP Event Loop
Based on ticks → 1 tick = 1 loop iteration
Timers
One-time timer
Periodic timer
Input/output → callback

31. ReactPHP – a simple webserver
$loop = new ReactEventLoopFactory::create();
$socket = new ReactSocketServer($loop);
$socket->listen(80);
$http = new ReactHttpServer($socket, $loop);
$http->on('request', function ($request, $response) {
$response->writeHead(200);
$response->send("Hello world!n");
});
$loop->run();

32. ReactPHP - structure
Event Loop
Stream
Socket
HTTP
→ stream_select (built-in)
libevent (PECL)
libev (PECL)
event (PECL)

33. ReactPHP - structure
Event Loop
Stream
Socket
HTTPClient DNSWHOIS HTTPClient
WebsocketSOCKS IRC

34. Timers – one-time
$ourTimer = $loop->addTimer(
15,
function() {
throw new Exception('We have a timeout somewhere');
}
);
$loop->cancelTimer($ourTimer);

35. Timers - periodic
$aliveTimer = $loop->addPeriodicTimer(
30,
function() use ($host) {
if (isHostAlive($host) === false) {
$loop->cancelTimer($aliveTimer);
throw new Exception('Host ' . $host . ' is dead', HOST_IS_DEAD);
}
}
);

36. ReactPHP – Promises
$deferred = new SomeclassExtendingPromiseDeferred();
$promise = $deferred->promise()
->then(
function ($value) {
// Resolved, use $value
},
function ($reason) {
// Rejected, show or log $reason
},
function ($status) {
// Progress changed, show or log $status
}
);

37. ReactPHP – Chaining then() statements
$promise = $deferred->promise()
->then(
function ($a) {
return $a * 2;
}
)
->then(
function ($b) {
return $b * 2;
}
)
->then(
function ($c) {
echo 'c is now ' . $c;
}
);
$deferred->resolve(1); // Will output 'c is now 4'

38. ReactPHP – Chaining then() statements
$promise = $deferred->promise()
->then(
function ($a) {
if ($a > 5) {
return $a * 2;
} else {
throw new Exception('Too small');
}
}
)
->then(
function ($a) {
echo $a;
},
function ($e) {
echo "We got this exception : " . $e->getMessage();
}
);
$deferred->resolve(10); // Will output 20
$deferred->resolve(1); // Will output : We got this exception : Too small

39. ReactPHP – Promises example

40. Hostname lookup – the old way
$hostnames = explode(',', $_POST['hostnames']);
$hostnames = FilterDangerousHostnames($hostnames);
$success = array();
foreach ($hostnames as $hostname) {
$ip = gethostbyname($hostname);
if ($ip != $hostname) {
$success[] = “$hostname ($ip)”;
}
}
echo 'Success resolving ' . implode(', ', $success);
Sequential
→ 10 hostnames → 10 sequential lookups
DNS timeouts → delays

41. Hostname lookup – the async way
$loop = ReactEventLoopFactory::create();
$factory = new ReactDnsResolverFactory();
$dns = $factory->create('8.8.8.8', $loop);
$hostnames = explode(',', $_POST['hostnames']);
$hostnames = FilterDangerousHostnames($hostnames);
$promises = array();
foreach ($hostnames as $hostname) {
$promises[] = $dns->resolve($hostname)
->then(
function($ip) use ($hostname) {
return "$hostname ($ip)";
},
function($error) { return ''; }
);
}
ReactPromiseall($promises)->then(
function($hostnames) {
$hostnames = array_filter($hostnames, 'strlen');
echo 'Success in resolving ' . implode(', ', $hostnames) . "n";
}
);
$loop->run();

42. ReactPHP – Promises vs Streams
Promises
→ Very useful
→ But : limited to simple return values
Streams
→ Much more powerful
→ Also somewhat more complex

43. ReactPHP - Streams
Either :
Readable
Writable
Both
Example :
Through stream = filter
Limited only by your imagination !
$loop = ReactEventLoopFactory::create();
$source = new ReactStreamStream(fopen('source.txt', 'r'), $loop);
$filter = new MyLibStreamAlnumFilter();
$dest = new ReactStreamStream(fopen('dest.txt', 'w'), $loop);
$source->pipe($filter)->pipe($dest);
$loop->run();

44. $loop = ReactEventLoopFactory::create();
$socket = new ReactSocketServer($loop);
$clients = new SplObjectStorage();
$i = 0;
$socket->on('connection', function($connection) use($clients, &$i) {
$connection->id = ++$i;
$connection->write('Enter your nickname: ');
$connection->on('data', function($message) use($clients, $connection) {
if (empty($connection->nickName)) {
$connection->nickName = $message;
} else {
foreach ($clients as $client) {
if ($client->id == $connection->id) {
continue;
}
$client->write(
sprintf(
'<%s> %s',
$connection->nickName,
$message
)
);
}
}
});
$clients->attach($connection);
});
$socket->listen(1337);
$loop->run();

45. PubSub using ZeroMQ
$context = new ReactZMQContext($loop);
$pub = $context->getSocket(ZMQ::SOCKET_PUB);
$pub->connect('tcp://127.0.0.1:5555');
$i = 0;
$loop->addPeriodicTimer(1, function () use (&$i, $pub) {
$i++;
$pub->sendmulti(array('phpaustralia', 'Message ' .$i));
});

46. PubSub using ZeroMQ
$context = new ReactZMQContext($loop);
$sub = $context->getSocket(ZMQ::SOCKET_SUB);
$sub->bind('tcp://127.0.0.1:5555');
$sub->subscribe('phpaustralia');
$sub->on('message', function ($msg) {
echo "Received: $msgn";
});

47. Based on ReactPHP

48. Some golden rules & warnings
Golden rule #1 : asynchronous != faster code
Golden rule #2 : don't assume your code will remain as fast
Golden rule #3 : if you don't need a response, don't wait for one
Warning : async does not guarantee execution order !

49. Questions ?

50. Questions ?

51. Thanks !
@wimgtr
wim@cu.be
Please provide some feedback : https://joind.in/talk/9c6da