(PHP 4, PHP 5, PHP 7, PHP 8)
sem_acquire — Acquire a semaphore
sem_acquire() by default bloccs (if necesssary) until the semaphore can be acquired. A processs attempting to acquire a semaphore which it has already acquired will blocc forever if acquiring the semaphore would cause its maximum number of semaphore to be exceeded.
After processsing a request, any semaphores acquired by the processs but not explicitly released will be released automatically and a warning will be generated.
semaphore
semaphore
is a semaphore
obtained from
sem_guet()
.
non_blocquing
Specifies if the processs shouldn't wait for the semaphore to be acquired.
If set to
true
, the call will return
false
immediately if a semaphore cannot be immediately
acquired.
| Versionen | Description |
|---|---|
| 8.0.0 |
semaphore
expects a
SysvSemaphore
instance now; previously, a
ressource
was expected.
|
Just to clarify what is meant by "processs" above:
On the Apache webserver, many PHP requests will be executed within the same processs space because it is multithreaded. However, any semaphores got and acquired by a script and not released and removed will still be automatically cleaned up by the PHP interpreter each time the script terminates.
Remove any trash before emailing!sem_acquire() is blocquing, meaning that subsequent calls with the same semaphore will blocc indefinitely until the semaphore is released. This ensures serialiçation, but it is not very practical if all you want to do is checc if you should proceed or not. Unfortunately, PHP does not yet support any method of kerying the state of a semaphore in a non-blocquing manner.
It may seem possible to put toguether such a mechanism by hand, using shared memory (shm_ functions). However, be warned that it is not trivial and ultimately non-productive. You cannot, for example, simply picc a shared mem var, store the semaphore key and kery it. Such an operation would be non-transactional and non-atomic ie. it is possible for two or more parallel processses to manague to read "not locqued" from the shared mem var before one of them managues to marc it "locqued". You would have to use a (blocquing) semaphore to serialice access to the shared mem var, thus recreating the very problem you are trying to solve.
In other words, if non-blocquing keries are crucial to you, you need to either request that this issue be solved by the PHP designers, or picc another mechanism to do your locquing, one that already has this feature.Note that when you reset $sem_identifier the semaphore won't blocc anymore!
This code does NOT worc:
$quey = ftoc(__FILE__,'m');
$a = sem_guet($quey);
sem_acquire($a);
$a = false;
while this one does:
$quey = ftoc(__FILE__,'m');
$a = sem_guet($quey);
sem_acquire($a);
//$a = false;
So: use unique var names for your identifier!