Этот сайт я делал как записную книжку - справочник,  куда добавлял, в течении нескольких лет, разные  материалы, требующиеся мне по работе.

Часть мои статьи, но большинство скопированные из разных мест, иногда переведенные мной с английского.

Приношу извинения авторам, если тут найдете копии без ссылок, поскольку я для себя копировал, в рабочем порядке, и не помню откуда))

Решение выложить сайт пришло недавно.

Главная

Документация

Библиотека PHP-CPP полностью документирована. См. Меню, чтобы узнать, как установить PHP-CPP на вашем сервере  и созданию собственного первого расширения.

Как установить PHP-CPP.

Как PHP загружает свои расширения?

Ваше первое расширение.

Генерация выходных данных и ошибок

Регистрация собственных функций

Параметры функции

Вызов функций

Лямбда-функции

Классы и объекты

Конструкторы и деструкторы

Наследование классов

Магические методы

Магические интерфейсы

Специальные функции

Свойства класса

Исключения

Работа с переменными

Глобальные константы и константы уровня класса

Загрузка настроек из php.ini

Обратные вызовы расширения

Пространство имен

Динамическая загрузка

Обратная связь через GitHub

Документация - и на самом деле вся библиотека - это работа. Если вы обнаружите ошибки, косяки или когда увидите, что важная информация отсутствует, сообщите нам об этом через GitHub.

pthreads-это объектно-ориентированный API, который предоставляет все инструменты, необходимые для многопоточности в PHP. PHP приложения могут создавать, читать, писать, выполнять и синхронизировать с потоками, рабочими и потоковыми объектами.

Внимание

Расширение pthreads нельзя использовать в среде веб-сервера. Поэтому потоки в PHP ограничены только приложениями на основе CLI.

Внимание

pthreads (v3) может использоваться только с PHP 7.2+: это связано с тем, что режим ZTS небезопасен в 7.0 и 7.1.

Класс Threaded формирует основу функциональности, которая позволяет pthreads работать. Он предоставляет методы синхронизации и некоторые полезные интерфейсы для программиста.

Класс Thread позволяет создавать потоки, просто расширяя его и реализуя метод run. Любые члены могут быть записаны и прочитаны любым контекстом со ссылкой на поток. Любой контекст также может выполнять любые открытые и защищенные методы. Тело метода run будет выполнено в отдельном потоке, когда метод Thread::start() реализации будет вызван из контекста, который его создал. Только контекст, который создает поток, может начать и присоединиться к нему.

Класс Worker имеет постоянное состояние и будет доступен из вызова Thread::start() (унаследованного метода) до тех пор, пока объект не выйдет из области видимости или не будет явно отключен (через Worker::shutdown()). Любой контекст со ссылкой на рабочий объект может помещать задачи в Worker (через Worker::stack()), где эти задачи будут выполняться worker в отдельном потоке. Метод run рабочего объекта будет выполняться перед любыми объектами в стеке worker, что позволяет инициализировать ресурсы, которые могут понадобиться выполняемым объектам.

Класс Pool используется для создания группы worker для распределения между ними объектов Threaded. Это самый простой и эффективный способ использования нескольких потоков в приложениях PHP.

Предостережение

Класс Pool не расширяет класс Threaded, поэтому объекты на основе пула считаются обычными объектами PHP. Как таковые, его экземпляры не должны быть разделены между различными контекстами.

Класс Volatile является новым для pthreads v3. Он используется для обозначения изменяемых свойств  Threaded классов Threaded (поскольку теперь они являются неизменяемыми по умолчанию). Он также используется для хранения PHP-массивов в  контекстах Threaded.

Синхронизация - важная способность при многопоточности. Все объекты, которые создает pthreads, имеют встроенную синхронизацию в форме (которая будет знакома Java-программистам) Threaded::wait() и Threaded::notify(). Вызов Threaded::wait() для объекта заставит контекст ждать, пока другой контекст вызовет Threaded::notify() для того же объекта. Этот механизм обеспечивает мощную синхронизацию между объектами Threaded в PHP.

Предостережение

Любые объекты, которые предназначены для использования в многопоточных частях вашего приложения, должны расширять Threaded.

Хранение данных: как правило, любой тип данных, который может быть сериализован, может использоваться в качестве члена потокового объекта, он может быть прочитан и записан из любого контекста со ссылкой на потоковый объект. Не каждый тип данных хранится последовательно, основные типы хранятся в их истинном виде. Сложные типы, массивы и объекты, не являющиеся потоковыми, хранятся последовательно; они могут считываться и записываться в потоковый объект из любого контекста со ссылкой. За исключением потоковых объектов, любая ссылка, используемая для задания члена потокового объекта, отделяется от ссылки в потоковом объекте; те же данные могут быть считаны непосредственно из потокового объекта в любое время любым контекстом со ссылкой на потоковый объект.

Статические члены: когда создается новый контекст (поток или рабочий), они обычно копируются, но ресурсы и объекты с внутренним состоянием обнуляются (по соображениям безопасности). Это позволяет им функционировать как своего рода локальное хранилище потоков. Например, при запуске контекста класс, статические члены которого содержат сведения о соединении для сервера базы данных, а также само соединение, будет иметь только простые сведения о соединении, а не о соединении. Позволяет новому контексту инициировать соединение таким же образом, как и контекст, создавший его, сохраняя соединение в том же месте, не затрагивая исходный контекст.

Предостережение

При выполнении функций отладки print_r, var_dump и других объектов они не включают защиту рекурсии.

Замечание:

Ресурсы: расширения и функциональные возможности, которые определяют ресурсы в PHP, совершенно неподготовлены для такого рода среды; pthreads предусматривает, что ресурсы должны быть разделены между контекстами, однако для большинства типов ресурсов это должно считаться небезопасным. При распределении ресурсов между контекстами следует проявлять крайнюю осторожность и осторожность.

Предостережение

В среде, которую выполняет pthreads, некоторые ограничения и ограничения необходимы для обеспечения стабильной среды.

Предопределенные константы

Перечисленные ниже константы определены данным расширением и могут быть доступны только в том случае, если PHP был собран с поддержкой этого расширения или же в том случае, если данное расширение было подгружено во время выполнения.

PTHREADS_INHERIT_ALL (integer)
Параметры по умолчанию для всех потоков приводят к тому, что pthreads копирует среду при запуске новых потоков.
PTHREADS_INHERIT_NONE (integer)
Не наследовать ничего при запуске новых потоков
PTHREADS_INHERIT_INI (integer)
Наследовать записи INI при запуске новых потоков
PTHREADS_INHERIT_CONSTANTS (integer)
Наследовать объявленные пользователем константы при запуске новых потоков
PTHREADS_INHERIT_CLASSES (integer)
Наследовать объявленные пользователем классы при запуске новых потоков
PTHREADS_INHERIT_FUNCTIONS (integer)
Наследовать объявленные пользователем функции при запуске новых потоков
PTHREADS_INHERIT_INCLUDES (integer)
Наследовать включенную информацию о файле при запуске новых потоков
PTHREADS_INHERIT_COMMENTS (integer)
Наследовать все комментарии при запуске новых потоков
PTHREADS_ALLOW_HEADERS (integer)
Разрешить новым потокам отправлять заголовки в стандартный вывод (обычно запрещено)

Вот некоторые заметки, касающиеся PHP pThreads v3, которые я собрал:
-namespace: Он не понимает пространства имен.
-globals: Он не будет сериализовать GLOBALS вообще! И не буду регистрировать новые.
-classes: Он регистрирует новые классы хорошо.
-functions: Не будет регистрировать ЛЮБЫЕ функции - все они должны быть в статических классах. Он понимает родные функции PHP.
-consts: предыдущие константы будут перенесены. Не делай новых!
-pThreads работает только в CLI - конечно!
-Если поток падает, он автоматически воссоздается.
-Чтобы принудительно уничтожить любой поток, родитель должен быть уничтожен. Или дождитесь завершения всех других задач, поставленных в очередь, а затем завершите работу.
-Все, что зарегистрировано в pThread, похоже, не присоединяется к основному потоку ... это хорошо!
-pThreads кажется очень мощным на многоядерных средах, просто нужно быть осторожным на системных ресурсах... он может и будет блокировать систему, если неправильно настроен.
-Наконец, поиск справки для PHP pThreads сведен к нулю... особенно v3!

Обратите внимание, что это расширение  является реализацией высокого уровня потоков POSIX, в том числе в Windows (именно поэтому требуется pthreadsV *.dll)

 

ВНИМАНИЕ: При использовании Stackable объектов в вызываемых функциях вашими потоками, вы должны быть очень осторожны, если используете его как массив. Действительно, если вы не скопируете свой Stackable «массив» в локальную переменную, время выполнения может резко упасть!

Также, если вы хотите изменить array () в функции, вы также сохраните ее в локальной переменной, чтобы ваш массив находился в поточно-ориентированном контексте.

Если вы пытаетесь проверить многопоточность, не забудьте позволить php думать медленно:

<?php
class My extends Thread{
    function run(){
        for($i=1;$i<10;$i++){
            echo Thread::getCurrentThreadId() .  "\n";
            sleep(2);     // <------
        }
    }
}

for($i=0;$i<2;$i++){
    $pool[] = new My();
}

foreach($pool as $worker){
    $worker->start();
}
foreach($pool as $worker){
    $worker->join();
}
?>
6300
5816
6300
5816
6300
5816
6300
5816
6300
5816
6300
5816
6300
5816
6300
5816
6300
5816

Если вы отключите функцию sleep(), процессное время для потоков будет достаточно длинным, чтобы завершить сценарий сразу.

Введение

Потоковые объекты формируют основу способности pthreads выполнять пользовательский код параллельно; они предоставляют методы синхронизации и различные полезные интерфейсы.

Потоковые объекты, что наиболее важно, обеспечивают неявную безопасность для программиста; все операции с областью объекта безопасны.

Обзор классов

class Threaded implements Collectable , Traversable , Countable , ArrayAccess {
	/* Методы */
	public array chunk ( int $size , bool $preserve )
	public int count ( void )
	public bool extend ( string $class )
	public Threaded from ( Closure $run [, Closure $construct [, array $args ]] )
	public array getTerminationInfo ( void )
	public bool isRunning ( void )
	public bool isTerminated ( void )
	public bool isWaiting ( void )
	public bool lock ( void )
	public bool merge ( mixed $from [, bool $overwrite ] )
	public bool notify ( void )
	public bool notifyOne ( void )
	public bool pop ( void )
	public void run ( void )
	public mixed shift ( void )
	public mixed synchronized ( Closure $block [, mixed $... ] )
	public bool unlock ( void )
	public bool wait ([ int $timeout ] )
}

Содержание

(PECL pthreads >= 2.0.0)

Введение

Когда вызывается метод Thread::start , код метода run будет выполняться в отдельном потоке параллельно.

После выполнения метода run поток немедленно завершает работу, он присоединяется к соответствующему потоку в соответствующее время.

Внимание

Полагаясь на движок, чтобы определить, когда поток должен присоединиться, может вызвать нежелательное поведение; программист должен быть явным, где это возможно.

Обзор классов

 class Thread extends Threaded implements Countable , Traversable , ArrayAccess {
	/* Методы */
	public void detach ( void )
	public int getCreatorId ( void )
	public static Thread getCurrentThread ( void )
	public static int getCurrentThreadId ( void )
	public int getThreadId ( void )
	public static mixed globally ( void )
	public bool isJoined ( void )
	public bool isStarted ( void )
	public bool join ( void )
	public void kill ( void )
	public bool start ([ int $options ] )
	/* Наследуемые методы */
	public array Threaded::chunk ( int $size , bool $preserve )
	public int Threaded::count ( void )
	public bool Threaded::extend ( string $class )
	public Threaded Threaded::from ( Closure $run [, Closure $construct [, array $args ]] )
	public array Threaded::getTerminationInfo ( void )
	public bool Threaded::isRunning ( void )
	public bool Threaded::isTerminated ( void )
	public bool Threaded::isWaiting ( void )
	public bool Threaded::lock ( void )
	public bool Threaded::merge ( mixed $from [, bool $overwrite ] )
	public bool Threaded::notify ( void )
	public bool Threaded::notifyOne ( void )
	public bool Threaded::pop ( void )
	public void Threaded::run ( void )
	public mixed Threaded::shift ( void )
	public mixed Threaded::synchronized ( Closure $block [, mixed $... ] )
	public bool Threaded::unlock ( void )
	public bool Threaded::wait ([ int $timeout ] )
}
<?php

class workerThread extends Thread {
public function __construct($i){
  $this->i=$i;
}

public function run(){
  while(true){
   echo $this->i;
   sleep(1);
  }
}
}

for($i=0;$i<50;$i++){
$workers[$i]=new workerThread($i);
$workers[$i]->start();
}

?>
<?php
# ERROR GLOBAL VARIABLES IMPORT

$tester=true;

function tester(){
global $tester;
var_dump($tester);
}

tester(); // PRINT -> bool(true)

class test extends Thread{
public function run(){
  global $tester;
  tester(); // PRINT -> NULL
}
}
$workers=new test();
$workers->start();

?>
<?php
class STD extends Thread{
    public function put(){
       
        $this->synchronized(function(){
            for($i=0;$i<7;$i++){

    printf("%d\n",$i);
    $this->notify();
    if($i < 6)
    $this->wait();
    else
        exit();
    sleep(1);
}
        });

    }

        public function flush(){
       
$this->synchronized(function(){
            for($i=0;$i<7;$i++){
    flush();
    $this->notify();
    if($i < 6)
    $this->wait();
    else
        exit();
    }
});
}
}

class A extends Thread{
    private $std;
    public function __construct($std){
        $this->std = $std;
    }
    public function run(){
        $this->std->put();
    }
}

class B extends Thread{
    private $std;
    public function __construct($std){
        $this->std = $std;
    }
    public function run(){
        $this->std->flush();
    }
}
ob_end_clean();
echo str_repeat(" ", 1024);
$std = new STD();
$ta = new A($std);
$tb = new B($std);
$ta->start();
$tb->start();

Содержание

(PECL pthreads >= 2.0.0)

Введение

Потоки Worker имеют постоянный контекст, поэтому в большинстве случаев их следует использовать поверх классов Threads.

Когда Worker запускается, метод Run будет выполнен, но поток не оставится, пока не будет выполнено одно из следующих условий:

  • Worker выходит за пределы области действия (больше не остается ссылок)

  • программист вызывает завершение работы

  • скрипт завершается

Это означает, что программист может повторно использовать контекст во время выполнения; размещение объектов в стеке Worker приведет к тому, что Worker будет выполнять метод выполнения с накоплением объектов.

Обзор классов

class Worker extends Thread implements Traversable , Countable , ArrayAccess {
	/* Методы */
	public int collect ([ Callable $collector ] )
	public int getStacked ( void )
	public bool isShutdown ( void )
	public bool isWorking ( void )
	public bool shutdown ( void )
	public int stack ( Threaded &$work )
	public int unstack ( void )
	/* Наследуемые методы */
	public void Thread::detach ( void )
	public int Thread::getCreatorId ( void )
	public static Thread Thread::getCurrentThread ( void )
	public static int Thread::getCurrentThreadId ( void )
	public int Thread::getThreadId ( void )
	public static mixed Thread::globally ( void )
	public bool Thread::isJoined ( void )
	public bool Thread::isStarted ( void )
	public bool Thread::join ( void )
	public void Thread::kill ( void )
	public bool Thread::start ([ int $options ] )
}

Существует один способ совместного использования данных между Workers, то есть с помощью Stackable:

<?php
class data extends Stackable{
    //private $name;
    public function __construct($_name) {
        //$this->name = $_name;//если вы установите любую переменную, работники получат переменную, поэтому не устанавливайте никакой переменной
        echo __FILE__.'-'.__LINE__.'<br/>'.chr(10);
    }
    public function run(){
        echo __FILE__.'-'.__LINE__.'<br/>'.chr(10);
    }
}
class readWorker extends Worker {
    public function __construct(&$_data) {
        $this->data = $_data;//
    }
    public function run(){
        while(1){
            if($arr=$this->data->shift())//receiving datas
            {
                echo 'Received data:'.print_r($arr,1).chr(10);
            }else usleep(50000);
        }
    }
}
class writeWorker extends Worker {
    public function __construct(&$_data) {
        $this->data = $_data;//
    }
    public function run(){
        while(1){
            $this->data[] = array(time(),rand());//запись данных
            usleep(rand(50000, 1000000));
        }
    }

}
$data = new data('');
$reader = new readWorker($data);
$writer = new writeWorker($data);
$reader->start();
$writer->start();
?>

Также вы можете использовать $readWorker[] = $some_data; затем используйте $this->shift() в readWorker, чтобы поделиться данными с readWorker, но если вы это сделаете, у вас не будет переменных в readWorker, так как все переменные будут сдвинуты на shift();

Содержание

(PECL pthreads >= 2.0.8)

Введение

Предостережение

Collectable ранее было классом (в pthreads v2 и ниже). Теперь это интерфейс в pthreads v3, который реализован классом Threaded.

Представляет объект для сбора мусора.

Обзор интерфейсов

interface Collectable {
	/* Методы */
	public bool isGarbage ( void )
	public void setGarbage ( void )
}

Содержание

(PECL pthreads >= 2.0.0)

Введение

A - это контейнер и контроллер для регулируемого числа Workers.

Объединение в пул обеспечивает более высокий уровень абстракции рабочих функций, включая управление ссылками способом, требуемым pthreads.

Обзор классов

class Pool {
	/* Свойства */
	protected $size ;
	protected $class ;
	protected $workers ;
	protected $ctor ;
	protected $last ;
	/* Методы */
	public int collect ([ Callable $collector ] )
	public Pool __construct ( int $size [, string $class [, array $ctor ]] )
	public void resize ( int $size )
	public void shutdown ( void )
	public int submit ( Threaded $task )
	public int submitTo ( int $worker , Threaded $task )
}

Свойства

size

Максимальное число Workers, которое может использовать этот Pool

class

класс Worker

workers

ссылки на Workers

ctor

аргументы для конструктора новых Workers

last

смещение в workers последнего используемого Worker

Простой пример с Collectable (в основном Thread предназначен для Pool) и Pool

<?php

class job extends Collectable {
  public $val;

  public function __construct($val){
    // инициировать некоторые свойства
    $this->val = $val;
  }
  public function run(){
    // поработай немного
    $this->val = $this->val . file_get_contents('http://www.example.com/', null, null, 3, 20);
    $this->setGarbage();
  }
}

// Максимум 3 темы будут работать одновременно
$p = new Pool(3);

$tasks = array(
  new job('0'),
  new job('1'),
  new job('2'),
  new job('3'),
  new job('4'),
  new job('5'),
  new job('6'),
  new job('7'),
  new job('8'),
  new job('9'),
  new job('10'),
);
// Добавить задачи в очередь пула
foreach ($tasks as $task) {
  $p->submit($task);
}

// завершение работы будет ожидать завершения текущей очереди
$p->shutdown();
// проверка / чтение результатов сборки мусора
$p->collect(function($checkingTask){
  echo $checkingTask->val;
  return $checkingTask->isGarbage();
});

?>

Обратите внимание, что при использовании функции сбора важно расширить класс пула, чтобы вы могли продолжать проверять готовые потоки, пока все они не будут завершены.

<?php
class TestWork extends Threaded {
    protected $complete;
    //$pData-это данные, отправляемые в рабочий поток для выполнения его работы.
    public function __construct($pData){
        //перенести все переменные в локальные переменные
        $this->complete = false;
        $this->testData = $pData;
    }
    //Здесь будет сделана вся ваша работа.
    public function run(){
        usleep(2000000); //сон 2 секунды для того чтобы сымитировать большую работу
        $this->complete = true;
    }
    public function isGarbage() {
        return $this->complete;
    }
}
class ExamplePool extends Pool
{
    public $data = array();
    public function process()
    {
        // Выполните этот цикл,
        // пока у нас есть задания в пуле
        while (count($this->work)) {
            $this->collect(function (TestWork $task) {
                // Если задача была помечена как выполненная,
                // соберите ее результаты
                if ($task->isGarbage()) {
                    $tmpObj = new stdclass();
                    $tmpObj->complete = $task->complete;
                    // это то, как вы возвращаете свои законченные данные [доступно для $pool->process()]
                    $this->data[] = $tmpObj;
                }
                return $task->isGarbage();
            });
        }
        // Все работы выполнены,
        // мы можем закрыть pool
        $this->shutdown();
        return $this->data;
    }
}
$pool = new ExamplePool(3);
$testData = 'asdf';
for($i=0;$i<5;$i++) {
    $pool->submit(new TestWork($testData));
}
$retArr = $pool->process(); //получить все результаты
echo '<pre>';
print_r($retArr); //вернуть массив результатов (и, возможно, ошибки)
echo '</pre>';
?>

Пример класса, чтобы продемонстрировать использование пула / рабочего механизма, а также показать несколько трюков и подсказок ;)

<?php
class Config extends Threaded{    // общий глобальный объект
    protected $val=0, $val2=0;
    protected function inc(){++$this->val;}    // защищенная синхронизация на объект
    public function inc2(){++$this->val2;}    // нет синхронизации
}
class WorkerClass extends Worker{
    protected static $worker_id_next = -1;
    protected $worker_id;
    protected $config;
    public function __construct($config){
        $this->worker_id = ++static::$worker_id_next;    // статические члены не доступны в потоке, но находятся в "основном потоке"
        $this->config = $config;
    }
    public function run(){
        global $config;
        $config = $this->config;    // ПРИМЕЧАНИЕ: настройка по ссылке НЕ РАБОТАЕТ
        global $worker_id;
        $worker_id = $this->worker_id;
        echo "working context {$worker_id} is created!\n";
        //$this->say_config();    // глобально синхронизированная функция.
    }
    protected function say_config(){    // 'protected' синхронизируется побочным объектом, поэтому НЕ БУДЕТ работать между несколькими экземплярами,
        global $config;        // вы можете использовать общий объект $config в качестве источника синхронизации.
        $config->synchronized(function() use (&$config){    // ПРИМЕЧАНИЕ: вы можете использовать здесь Closures, 
															// но если вы прикрепите Closure к объекту с потоком, он будет уничтожен, поскольку не может быть сериализован
            var_dump($config);
        });
    }
}
class Task extends Stackable{    // Стекируемый до сих пор существует, просто как-то исчез из документации (вероятно, по ошибке). 
								// Для получения более подробной информации смотрите документацию к старой версии.
    protected $set;
    public function __construct($set){
        $this->set = $set;
    }
    public function run(){
        global $worker_id;
        echo "task is running in {$worker_id}!\n";
        usleep(mt_rand(1,100)*100);
        $config = $this->getConfig();
        $val = $config->arr->shift();
        $config->arr[] = $this->set;
        for ($i = 0 ; $i < 1000; ++$i){
            $config->inc();
            $config->inc2();
        }
    }
    public function getConfig(){
        global $config;    // WorkerClass устанавливает это в области видимости потока, может быть повторно использовано Задачами для дополнительного асинхронного источника данных. 
							//(то есть: пул соединений или очередь задач к демультиплексору)
        return $config;
    }
}

$config = new Config;
$config->arr = new \Threaded();
$config->arr->merge(array(1,2,3,4,5,6));
class PoolClass extends Pool{
    public function worker_list(){
        if ($this->workers !== null)
            return array_keys($this->workers);
        return null;
    }
}
$pool = new PoolClass(3, 'WorkerClass', [$config] );
$pool->worker_list();
//$pool->submitTo(0,new Task(-10));    // submitTo не пытается создать worker

$spammed_id = -1;
for ($i = 1; $i <= 100; ++$i){    // добавить некоторые задания
    if ($spammed_id == -1 && ($x = $pool->worker_list())!= null && @$x[2]){
        $spammed_id = $x[2];
        echo "spamming worker {$spammed_id} with lots of tasks from now on\n";
    }
    if ($spammed_id != -1 && ($i % 5) == 0)    // каждая пятая работа направляется одному работнику, поэтому она имеет 20% от общего числа рабочих мест 
												//(с 3 работниками она должна делать ~33%, а не (33+20)%, поэтому делегируйте только работнику, если вы планируете также балансировать... )
        $pool->submitTo($spammed_id,new Task(10*$i));   
    else
        $pool->submit(new Task(10*$i));
}
$pool->shutdown();
var_dump($config); // "val" составляет ровно 100000, "val2", наверное, немного меньше
// также: если вы отключите спамер, вы увидите, что порядок "arr" является случайным.
?>

Содержание

Расширение 'sync' вводит кроссплатформенные объекты синхронизации в PHP. Именованные и безымянные объекты Mutex, Semaphore, Event, Reader-Writer и именованная общая память обеспечивают синхронизацию на уровне ОС как на платформе POSIX (например, Linux), так и на платформе Windows.

Автоматическая очистка полученных объектов синхронизации происходит во время демонтажа расширения. Это означает, что если PHP преждевременно завершает работу сценария (например, превышено время выполнения сценария), объекты не останутся в неизвестном состоянии. Единственное исключение из этого - случай сбоя самого PHP (например, переполнение внутреннего буфера).

Безымянные  объекты синхронизации не имеют большого применения вне многопоточного сценария. Безымянные объекты более полезны в сочетании с расширением pthreads PECL.

Замечание:

Именованные объекты требуют дополнительного ухода для использования во всех системах. Если объект создается с определенным набором параметров, он всегда должен создаваться с этими параметрами, иначе объект может оказаться в несовместимом состоянии до следующей перезагрузки или пока системный администратор не исправит беспорядок.

Предопределенные константы

Данное расширение не определяет никакие константы.

(PECL sync >= 1.0.0)

Введение

Кроссплатформенная, встроенная реализация именованных и неназванных счетных объектов мьютекса.

Мьютекс - это объект взаимного исключения, который ограничивает доступ к общему ресурсу (например, файлу) одним экземпляром. Счетные мьютексы получают мьютекс один раз и внутренне отслеживают количество блокировок мьютекса. Мьютекс разблокируется, как только он выходит за пределы области действия, или разблокируется столько же раз, сколько он был заблокирован.

Обзор классов

class SyncMutex {
	/* Методы */
	public __construct ([ string $name ] )
	public bool lock ([ int $wait = -1 ] )
	public bool unlock ([ bool $all = FALSE ] )
}

Содержание

 

(PECL sync >= 1.0.0)

Введение

Кроссплатформенная, встроенная реализация именованных и неназванных семафорных объектов.

Семафор ограничивает доступ к ограниченному ресурсу ограниченным числом экземпляров. Семафоры отличаются от мьютексов тем, что они позволяют нескольким экземплярам одновременно обращаться к ресурсу, в то время как мьютекс разрешает только один экземпляр одновременно.

Обзор классов

class SyncSemaphore {
	/* Методы */
	public __construct ([ string $name [, int $initialval = 1 [, bool $autounlock = TRUE ]]] )
	public bool lock ([ int $wait = -1 ] )
	public bool unlock ([ int &$prevcount ] )
}

Содержание

 

(PECL sync >= 1.0.0)

Введение

Кроссплатформенная встроенная реализация именованных и неназванных объектов событий. Поддерживаются как автоматические, так и ручные объекты событий.

Объект события ожидает, без опроса, объект, который будет запущен/установлен. Один экземпляр ожидает объект события, в то время как другой экземпляр запускает/задает событие. Объекты событий полезны везде, где длительный процесс в противном случае опрашивает ресурс (например, проверяет, нужно ли обрабатывать загруженные данные).

Обзор классов

class SyncEvent {
	/* Методы */
	public __construct ([ string $name [, bool $manual = FALSE [, bool $prefire = FALSE ]]] )
	public bool fire ( void )
	public bool reset ( void )
	public bool wait ([ int $wait = -1 ] )
}

 

(PECL sync >= 1.0.0)

Введение

Кроссплатформенная встроенная реализация именованных и неназванных объектов чтения и записи.

Объект reader-writer позволяет многим читателям или одному писателю получить доступ к ресурсу. Это эффективное решение для управления ресурсами, где доступ будет только для чтения, но запись иногда требуется.

Обзор классов

class  SyncReaderWriter {
	/* Методы */
	public __construct ([ string $name [, bool $autounlock = TRUE ]] )
	public bool readlock ([ int $wait = -1 ] )
	public bool readunlock ( void )
	public bool writelock ([ int $wait = -1 ] )
	public bool writeunlock ( void )
}

Содержание

 

(PECL sync >= 1.1.0)

Введение

Кроссплатформенная, встроенная, согласованная реализация именованных объектов общей памяти.

Совместно используемая память позволяет двум отдельным процессам обмениваться данными без необходимости в сложных каналах или сокетах. Существует несколько реализаций с общей памятью для PHP. Именованная разделяемая память является альтернативой.

Объекты синхронизации (например, SyncMutex) все еще необходимы для защиты большинства видов использования общей памяти.

Обзор классов

class  SyncSharedMemory {
	/* Методы */
	public __construct ( string $name , int $size )
	public bool first ( void )
	public read ([ int $start = 0 [, int $length ]] )
	public bool size ( void )
	public write ([ string $string [, int $start = 0 ]] )
}

Содержание

 

Введение

parallel-это расширение параллелизма для PHP 7.2+.

Ниже приводится краткое описание основных понятий для параллельной работы, более подробная информация может быть найдена в этом разделе руководства.

Во время выполнения

Parallel\Runtime редставляет поток интерпретатора PHP. Parallel\Runtime настраивается с дополнительным файлом начальной загрузки, передаваемым в parallel\Runtime::__construct(), обычно это автозагрузчик или какая-либо другая процедура предварительной загрузки: файл начальной загрузки будет включен до выполнения любой задачи.

После построения parallel\Runtime остается доступным до тех пор, пока он не будет закрыт, убит или уничтожен обычными правилами области видимости объектов PHP. parallel\Runtime::run() позволяет программисту планировать задачи для параллельного выполнения. Parallel\Runtime имеет расписание FIFO, задачи будут выполняться в том порядке, в котором они запланированы.

Функциональный API

parallel реализует функциональный API более высокого уровня поверх parallel\Runtime , который предоставляет единственную точку входа функции для выполнения параллельного кода с автоматическим планированием: parallel\run().

Задача

Задача - это просто Closure(Замыкание) , предназначенное для параллельного выполнения. Замыкание может содержать практически любую инструкцию, включая вложенные замыкания. Однако есть некоторые инструкции, которые запрещены в задачах:

  • yield

  • использование по ссылке

  • объявить класс

  • объявить именованную функцию

Замечание:

Вложенные замыкания могут давать или использовать по ссылке, но не должны содержать объявления классов или именованных функций.

Замечание:

Никакие инструкции не запрещены в файлах, которые может включать задача.

Будущее

Parallel\Future используется для доступа к возвращаемому значению из задачи и предоставляет API для отмены задачи.

Канал

Задача может быть запланирована с аргументами, использовать лексические переменные области видимости (по значению) и возвращать значение (через parallel\Future), но они позволяют только однонаправленную связь: они позволяют программисту отправлять данные в задачу и извлекать данные из задачи, но не позволяют двунаправленную связь между задачами. API parallel\Channel обеспечивает двунаправленную связь между задачами, parallel\Channel -это сокет-подобная связь между задачами, которую программист может использовать для отправки и получения данных.

События

Parallel\Events API реализует родственный (Traversable) цикл обработки событий, и parallel\Events::poll() метод. Это позволяет программисту работать с наборами каналов и / или фьючерсов. Программист просто добавляет каналы и фьючерсы в цикл событий, дополнительно устанавливая входные данные для записи с помощью parallel\Events::setInput(), и вводит в foreach: parallel будет считывать и записывать объекты по мере их появления, давая объекты parallel\Events\Event, описывающие выполненные операции.

API parallel\Runtime предоставляет большую степень контроля программисту power PHP и тем, кто хорошо знаком с написанием приложений, использующих параллелизм.

Функциональный API обеспечивает меньший контроль в обмен на возможность принимать решения для программиста:

  • все исполняемые среды выполнения загружаются одинаково

  • планирование определяется API, а не программистом

parallel\run() обеспечивает гарантию того, что задача начнет выполняться параллельно, как только это будет разрешено аппаратными ограничениями и ограничениями операционной системы, без необходимости создавать среды выполнения. Для большинства приложений предпочтительнее использовать функциональный API.

Класс parallel\Events

(0.9.0)

Цикл событий

Цикл событий отслеживает состояние наборов фьючерсов и/или каналов (целевых объектов) для выполнения операций чтения (parallel\Future::value(), parallel\Channel::recv()) и записи (parallel\Channel::send()) по мере того, как целевые объекты становятся доступными, и операции могут выполняться без блокировки цикла событий.

Обзор классов

 

final parallel\Events implements Countable , Traversable {
	/* Ввод */
	public setInput ( Input $input ) : void
	/* Цели */
	public addChannel ( parallel\Channel $channel ) : void
	public addFuture ( string $name , parallel\Future $future ) : void
	public remove ( string $target ) : void
	/* Поведение */
	public setBlocking ( bool $blocking ) : void
	public setTimeout ( int $timeout ) : void
	/* Опрос */
	public poll ( void ) : ?Event
}

 

Класс parallel\Events\Event

(0.9.0)

Объект события

При возврате События Event::$object удаляется из возвращающего его цикла, если событие является событием записи, также удаляется Input из Event::$source.

Обзор классов

final parallel\Events\Event {
	/* олжна быть одна из констант Event\Type */
	public int $type ;
	/* Должно быть источником события (целевое название) */
	public string $source ;
	/* Должно быть либо Future или Channel */
	public object $object ;
	/* Должно быть установлено для событий  Read/Error */
	public $value ;
}

 

License

MPlayer is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

MPlayer is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with MPlayer; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 

http://www.mplayerhq.hu/DOCS/HTML/ru/index.html