php pthreads locking variable

Static variables are thread local, so you cannot use a static variable as a shared counter.

The following code will create a stupid number of threads (100), each thread accepts a Threaded result object and an int $value.

If $value is an even number we consider it a success, otherwise it is a failure; we execute an appropriate function to increment a shared counter safely.

<?php
class Results extends Threaded {

    public function addError() {
        return $this->synchronized(function(){
            return $this->error++;
        });
    }

    public function addSuccess() {
        return $this->synchronized(function(){
            return $this->success++;
        });
    }

    private $error;
    private $success;
}

class Process extends Thread {

    public function __construct(Results $results, int $value) {
        $this->results = $results;
        $this->value = $value;
    }

    public function run() {
        if ($this->value % 2 == 0)
            $this->results->addSuccess();
        else $this->results->addError();
    }

    private $results;
    private $value;
}

$results   = new Results();
$processes = [];
$process   = 0;

do {
    $processes[$process] = 
        new Process($results, mt_rand(1, 100));
    $processes[$process]->start();
} while (++$process < 100);

foreach ($processes as $process)
    $process->join();

var_dump($results);
?>

Note: this is PHP 7 + pthreads v3 code ... don't use v2 for new projects

Calling synchronized ensures that no other context can enter a synchronized block for the same object while the calling context is, this ensures safety for the operations provided in the synchronized block:

object(Results)#1 (2) {
  ["error"]=>
  int(49)
  ["success"]=>
  int(51)
}

The inquisitive programmer will probably now proceed to removing the synchronized blocks, and, much to their surprise will find that the output is the same.

The reason for this is because operations on objects members are atomic - the increment and decrement instructions can be assumed to be atomic, in other words.

It's too hard for you to guess which operations are going to be atomic, so don't.

Assumptions are horrible; as soon as the code in the synchronized block is more complex than single instructions your code is open to race conditions. The sensible thing to do is set a standard that says if you require atomicity for any number of statements they should be executed in a synchronized block.