PHP lock process until awaken or timeout reached

Question

I want a PHP script to lock itself (ie wait without CPU usage, no polling) until either awaken by other PHP script or a specific timeout of X seconds is reached.

Additionally, I want the IPC to work in a binary semaphore fashion except for the fact that the process releasing the semaphore wouldn't be the one acquiring it. Apparently this is not possible with sem_release():

sem_release() releases the semaphore if it is currently acquired by the calling process, otherwise a warning is generated.

The process acquiring the lock takes care of processing a bulk of data that whoever releases the semaphore is indicating that it's ready to be processed. Let us name P1 the process working on the data, and P2 the process that generates data and thus indicates P1 that new data is available for processing. New data may be made available to P1 by P2 several times while P1 is processing other data, but when P1 decides to process new data ALL of it is processed which means that P1 should not acquire every time P2 has signaled that there's new data. Two successive runs of P1 should block if no data has been made available in between.

This is why I am trying to achieve:

Time     Event                       Semaphore Status
  0     P1 attempts acquire     Unavailable / Process waiting
  1     P2 releases              Available / Process waiting
        P1 acquires              Unavailable / Process running
  2     P2 releases              Available  / Process running
  3     P2 releases              Available  / Process running
  4     P1 acquires             Unavailable / Process running
  5     P1 attempts acquire     Unavailable / Process waiting
------- after X seconds
 10     TimeOut, P1 goes on     Unavailable / Process running
 11     P2 releases             Available   / Process running
 12     P1 acquires             Unavailable / Process running
 ...

I am afraid that using other methods like message queues and such may lead to missing certain events (i.e. looping until queue is empty in order to clear it) so I'd like to keep it simple.

I'd like to use PHP only but a Linux host could be assumed.

Answer 1

I think the (only?) way you can get away with this if you want another process than the one acquiring the lock to be the one to release it would be to store the lock in shared memory.

For instance, make a class that acts as a lock using a lock file or something similar, store the lock object in shared memory, access it in the secondary process and release it.

I normally use lockfiles etc to make sure a secondary process does NOT run a certain piece of code while some other process is running it. So only the process that created the lock can release it. So how you want to keep track of which of your parallell processes are allowed to release the lock is something for you to figure out.

PHP Shared Memory