Home » Php » concurrency – How to implement event listening in PHP

concurrency – How to implement event listening in PHP

Posted by: admin July 12, 2020 Leave a comment


here is my problem: I have a script (let’s call it comet.php) whic is requsted by an AJAX client script and wait for a change to happen like this:

    //check for changes

I don’t like this too much, it’s not very scalable and it’s (imho) “bad practice”
I would like to improve this behaviour with a semaphore(?) or anyway concurrent programming
technique. Can you please give me some tips on how to handle this? (I know, it’s not a short answer, but a starting point would be enough.)

Edit: what about LibEvent?

How to&Answers:

You can solve this problem using ZeroMQ.

ZeroMQ is a library that provides supercharged sockets for plugging things (threads, processes and even separate machines) together.

I assume you’re trying to push data from the server to the client. Well, a good way to do that is using the EventSource API (polyfills available).


Connects to stream.php through EventSource.

var stream = new EventSource('stream.php');

stream.addEventListener('debug', function (event) {
    var data = JSON.parse(event.data);
    console.log([event.type, data]);

stream.addEventListener('message', function (event) {
    var data = JSON.parse(event.data);
    console.log([event.type, data]);


This is a long-running process that listens for incoming messages and sends them out to anyone listening.


$context = new ZMQContext();

$pull = $context->getSocket(ZMQ::SOCKET_PULL);

$pub = $context->getSocket(ZMQ::SOCKET_PUB);

while (true) {
    $msg = $pull->recv();
    echo "publishing received message $msg\n";


Every user connecting to the site gets his own stream.php. This script is long-running and waits for any messages from the router. Once it gets a new message, it will output this message in EventSource format.


$context = new ZMQContext();

$sock = $context->getSocket(ZMQ::SOCKET_SUB);
$sock->setSockOpt(ZMQ::SOCKOPT_SUBSCRIBE, "");

ini_set('memory_limit', '512M');

header("Content-Type: text/event-stream");
header("Cache-Control: no-cache");

while (true) {
    $msg = $sock->recv();
    $event = json_decode($msg, true);
    if (isset($event['type'])) {
        echo "event: {$event['type']}\n";
    $data = json_encode($event['data']);
    echo "data: $data\n\n";

To send messages to all users, just send them to the router. The router will then distribute that message to all listening streams. Here’s an example:


$context = new ZMQContext();

$sock = $context->getSocket(ZMQ::SOCKET_PUSH);

$msg = json_encode(array('type' => 'debug', 'data' => array('foo', 'bar', 'baz')));

$msg = json_encode(array('data' => array('foo', 'bar', 'baz')));

This should prove that you do not need node.js to do realtime programming. PHP can handle it just fine.

Apart from that, socket.io is a really nice way of doing this. And you could connect to socket.io to your PHP code via ZeroMQ easily.

See also


It really depends on what you are doing in your server side script. There are some situations in which your have no option but to do what you are doing above.

However, if you are doing something which involves a call to a function that will block until something happens, you can use this to avoid racing instead of the usleep() call (which is IMHO the part that would be considered “bad practice”).

Say you were waiting for data from a file or some other kind of stream that blocks. You could do this:

while (($str = fgets($fp)) === FALSE) continue;
// Handle the event here

Really, PHP is the wrong language for doing stuff like this. But there are situations (I know because I have dealt with them myself) where PHP is the only option.


As much as I like PHP, I must say that PHP isn’t the best choice for this task.
Node.js is much, much better for this kind of thing and it scales really good. It’s also pretty simple to implement if you have JS knowledge.

Now, if you don’t want to waste CPU cycles, you have to create a PHP script that will connect to a server of some sort on a certain port. The specified server should listen for connections on the chosen port and every X amount of time check for whatever you want to check (db entries for new posts for example) and then it dispatches the message to every connected client that the new entry is ready.

Now, it’s not that difficult to implement this event queue architecture in PHP, but it’d take you literally 5 minutes to do this with Node.js and Socket.IO, without worrying whether it’ll work in majority of browsers.


I agree with the consensus here that PHP isn’t the best solution here. You really need to be looking at dedicated realtime technologies for the solution to this asynchronous problem of delivering data from your server to your clients. It sounds like you are trying to implement HTTP-Long Polling which isn’t an easy thing to solve cross-browser. It’s been tackled numerous times by developers of Comet products so I’d suggest you look at a Comet solution, or even better a WebSocket solution with fallback support for older browsers.

I’d suggest that you let PHP do the web application functionality that it’s good at and choose a dedicated solution for your realtime, evented, asynchronous functionality.


You need a realtime library.

One example is Ratchet http://socketo.me/

The part that takes care of the pub sub is discussed at http://socketo.me/docs/wamp

The limitation here is that PHP also needs to be the one to initiate the mutable data.

In other words this wont magically let you subscribe to when MySQL is updated. But if you can edit the MySQL-setting code then you can add the publish part there.