parallel\Sync — Klasse · PHP-Referenz

Signatur

class parallel\Sync

Beschreibung

parallel\Sync ist Teil der parallel-Erweiterung und ermöglicht die sichere Koordination zwischen mehreren parallel laufenden Tasks (Threads). Es stellt einen gemeinsam nutzbaren skalaren Wert bereit, auf den mehrere Laufzeitkontexte kontrolliert zugreifen können, sowie Mechanismen zum Sperren (Locking) und zum Signalisieren (Wait/Notify).

Das Objekt kapselt intern ein Mutex-Lock sowie eine Condition-Variable. Mit wait() und notify() können Threads auf Ereignisse anderer Threads warten bzw. diese auslösen – ähnlich wie in Java mit Object.wait() und Object.notifyAll(). Der eingebettete skalare Wert (int, float, string, bool oder null) ist atomar les- und schreibbar.

parallel\Sync-Objekte können zwischen Laufzeitkontexten geteilt werden, da sie von der parallel-Erweiterung als teilbare Werte behandelt werden. Sie eignen sich vor allem für einfache Rendezvous-Muster, Flags oder Zähler, die von mehreren Threads gleichzeitig verwendet werden sollen.

Für komplexe Datenaustausch-Szenarien zwischen Tasks sollte stattdessen parallel\Channel verwendet werden. parallel\Sync ist dagegen ideal für Low-Level-Koordination wie das Warten auf eine bestimmte Bedingung oder das Schützen kritischer Abschnitte.

Parameter

Name	Typ	Default	Beschreibung
$value	scalar	0	Optionaler initialer skalarer Wert (int, float, string, bool oder null), der von allen Threads gemeinsam gelesen und geschrieben werden kann.

Rückgabewert

Typ

Beispiele

Einfaches Rendezvous-Muster zwischen Task und Hauptthread

<?php
use parallel\{Runtime, Sync};

$sync = new Sync(0);

$runtime = new Runtime();
$future = $runtime->run(function (Sync $sync): void {
    // Simuliere Arbeit
    sleep(1);
    // Wert setzen und Hauptthread benachrichtigen
    $sync(function () use ($sync): void {
        $sync->set(1);
    });
    $sync->notify();
}, [$sync]);

// Warten bis der Task fertig ist
$sync->wait();

echo 'Task abgeschlossen, Wert: ' . $sync->get() . PHP_EOL;
$future->value();
?>

Task abgeschlossen, Wert: 1

Kritischen Abschnitt mit dem Callable-Aufruf schützen

<?php
use parallel\{Runtime, Sync};

$sync = new Sync(0);
$runtimes = [];

for ($i = 0; $i < 4; $i++) {
    $runtimes[] = (new Runtime())->run(function (Sync $sync, int $id): void {
        // Kritischen Abschnitt durch Aufruf des Sync-Objekts schützen
        $sync(function () use ($sync, $id): void {
            $current = $sync->get();
            $sync->set($current + 1);
            echo "Task $id erhöht Zähler auf: " . $sync->get() . PHP_EOL;
        });
    }, [$sync, $i]);
}

foreach ($runtimes as $future) {
    $future->value();
}

echo 'Endwert: ' . $sync->get() . PHP_EOL;
?>

Task 0 erhöht Zähler auf: 1 Task 1 erhöht Zähler auf: 2 Task 2 erhöht Zähler auf: 3 Task 3 erhöht Zähler auf: 4 Endwert: 4

// Wichtig · Fallstricke

Verfügbarkeit: parallel\Sync erfordert die PECL-Erweiterung parallel ab Version 1.1.0 sowie PHP 8.0+ mit ZTS (Zend Thread Safety). Ohne ZTS ist die Erweiterung nicht verwendbar.

Deadlock-Gefahr: Bei falschem Einsatz von wait() ohne passendes notify() kann es zu einem dauerhaften Deadlock kommen. Stets sicherstellen, dass jedes wait() durch ein entsprechendes notify() oder notify(true) (für alle Wartenden) aufgelöst wird.

Nur skalare Werte: Der interne Wert von parallel\Sync kann nur skalare Typen aufnehmen (int, float, string, bool, null). Arrays oder Objekte werden nicht unterstützt – dafür ist parallel\Channel besser geeignet.

Callable-Aufruf für atomare Operationen: Der empfohlene Weg für Read-Modify-Write-Operationen ist, $sync direkt als aufrufbares Objekt zu verwenden: $sync(function() use ($sync) { ... }). Dies sperrt intern das Mutex für die Dauer des Closures.

Siehe auch

parallel\Channel parallel\Runtime parallel\Future parallel\Events