Threaded objects are already thread safe, that is, at any time when you read, write, check for the presence or delete (cancel) an element, the operation is atomic - no other context can perform any of the above operations when the first operation is performed. The same is true for engine handlers that the user does not know, all the way to the lowest level implicitly safe.
Enough reassurance ... This has obvious limitations when the logic becomes more complex, for example, checking for the existence of a member before installing or doing something else with it, as you do. Although operations on an object are atomic, there is nothing to stop another unset context with an element between isset calling and the call to read the property / dimension.
This applies to PHP7 (pthreads v3 +)
Security and integrity are two different things. When integrity is important, you can use Threaded::synchronized in PHP7 to save it correctly. In PHP5, you can also save it, but the code will be more complex, as well as the explanation.
The second example should run endlessly if I understand its logic. So I'm using this assumption to build the right code, I'm going to make additional assumptions about what you might want to do in this endless loop, and provide some idea of where it seems to be required.
<?php class Referee extends Threaded { public function find(string $ident, Threaded $reference) { return $this->synchronized(function () use($ident, $reference) { if (isset($this[$ident])) { return $this[$ident]; } else return ($this[$ident] = $reference); }); } public function foreach(Closure $closure) { $this->synchronized(function() use($closure) { foreach ($this as $ident => $reference) { $closure($ident, $reference); } }); } } class Test extends Thread { public function __construct(Referee $referee, string $ident, bool $delay) { $this->referee = $referee; $this->ident = $ident; $this->delay = $delay; } public function run() { while (1) { if ($this->delay) { $this->synchronized(function(){ $this->wait(1000000); }); } $reference = $this->referee->find($this->ident, $this); $this->referee->foreach(function($ident, $reference){ var_dump(Thread::getCurrentThreadId(), $reference->getIdent(), $reference->isRunning()); }); } } public function getIdent() { return $this->ident; } private $referee; private $ident; private $delay; } $referee = new Referee(); $threads = []; $thread = 0; $idents = [ "smelly", "dopey", "bashful", "grumpy", "sneezy", "sleepy", "happy", "naughty" ]; while ($thread < 8) { $threads[$thread] = new Test($referee, $idents[$thread], rand(0, 1)); $threads[$thread]->start(); $thread++; } foreach ($threads as $thread) $thread->join(); ?>
So, we will look at the differences, I will tell you why they are what they are, and how else you could write them, you already know that now we are not talking about security, but about integrity, you are given a (very remarkable) assumption that everything you write is “safe,” as explained.
The first important difference is the following:
if ($this->delay) { $this->synchronized(function(){ $this->wait(1000000); }); }
This is just a suitable way to wait for Thread , you will not need to use Thread for synchronization, you can use any Threaded object. The advantage of doing things right if it is not clear that sleeping and sleeping do not leave threads in a susceptible state using ::wait .
In the real world, where you really only have to wait for something, it will be a more complex block, it can (and should) look more:
if ($this->delay) { $this->synchronized(function(){ while ($this->condition) { $this->wait(1000000); } }); }
Note: waiting for a timeout is technically waiting for something, however you can be awakened by something other than the timeout reached, and the code should be ready for this.
Thus, another context may notify Thread that it should stop waiting and shutting down gracefully or perform some other important action immediately, simply by synchronizing, changing the state, and notifying Thread .
For predictable code, it is extremely important that it is convenient how to synchronize, wait and notify work.
Next, we have our logic for setting and getting the link:
$reference = $this->referee->find($this->ident, $this);
What causes this:
public function find(string $ident, Threaded $reference) { return $this->synchronized(function () use($ident, $reference) { if (isset($this[$ident])) { return $this[$ident]; } else return ($this[$ident] = $reference); }); }
It is poorly named, it is difficult to name things, but you can see that integrity is maintained by synchronization, while these grouped operations take place. The same method can also be used to get a link to another object with a small amount of settings.
I think you are doing something with this specific link (which will always be $this for now). I can’t guess. Moving on ...
I made the assumption that you want to do something with each of these Threads , and you want to maintain data integrity during the entire iteration:
$this->referee->foreach(function($ident, $reference){ var_dump(Thread::getCurrentThreadId(), $reference->getIdent(), $reference->isRunning()); });
What causes:
public function foreach(Closure $closure) { $this->synchronized(function() use($closure) { foreach ($this as $ident => $reference) { $closure($ident, $reference); } }); }
So you would do that.
It is worth mentioning that synchronization is not necessarily required here; just as nothing bad happens if you remove an element from the array you iterate, nothing bad happens if you cancel or set or do something else for the object during iteration.