Thread — Klasse · PHP-Referenz

Signatur

class Thread extends Threaded implements Countable, Traversable, ArrayAccess

Beschreibung

Thread ist die zentrale Klasse der pthreads-Erweiterung und ermöglicht echtes Multi-Threading in PHP. Durch Ableitung von Thread und Implementierung der Methode run() kann Code in einem separaten Betriebssystem-Thread parallel zum Haupt-Thread (oder zu anderen Threads) ausgeführt werden.

Um einen Thread zu starten, erstellt man eine Instanz der abgeleiteten Klasse und ruft start() auf. Die Logik, die parallel laufen soll, wird in der überschriebenen run()-Methode definiert. Mit join() wartet der aufrufende Thread auf die Beendigung des gestarteten Threads.

Da Thread von Threaded erbt, sind Instanzen thread-sicher: Eigenschaften können von mehreren Threads gelesen und geschrieben werden, wobei die Synchronisation über eingebaute Mutex-Mechanismen (synchronized(), wait(), notify()) erfolgt.

Hinweis: Die pthreads-Erweiterung ist nur für die CLI-SAPI verfügbar und wird seit PHP 8.x nicht mehr aktiv weiterentwickelt. Für moderne Anwendungen sollte parallel\Runtime (Erweiterung parallel) als Alternative in Betracht gezogen werden.

Parameter

Name	Typ	Default	Beschreibung
$...	mixed		Der Konstruktor von `Thread` selbst nimmt keine Parameter entgegen. Abgeleitete Klassen können ihren eigenen Konstruktor definieren, um beliebige Daten an den Thread zu übergeben.

Rückgabewert

Typ

Beispiele

Einfacher Thread mit paralleler Ausgabe

<?php
class MeinThread extends Thread
{
    private string $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }

    public function run(): void
    {
        for ($i = 1; $i <= 3; $i++) {
            echo "Thread {$this->name}: Schritt {$i}" . PHP_EOL;
            usleep(100_000); // 100 ms
        }
    }
}

$t1 = new MeinThread('A');
$t2 = new MeinThread('B');

$t1->start();
$t2->start();

$t1->join();
$t2->join();

echo "Beide Threads abgeschlossen." . PHP_EOL;

Thread A: Schritt 1 Thread B: Schritt 1 Thread A: Schritt 2 Thread B: Schritt 2 Thread A: Schritt 3 Thread B: Schritt 3 Beide Threads abgeschlossen.

Gemeinsam genutzte Daten zwischen Threads synchronisieren

<?php
class ZaehlerThread extends Thread
{
    public int $ergebnis = 0;

    public function run(): void
    {
        $summe = 0;
        for ($i = 1; $i <= 1000; $i++) {
            $summe += $i;
        }
        // Schreiben der Eigenschaft ist thread-sicher durch Threaded
        $this->ergebnis = $summe;
    }
}

$thread = new ZaehlerThread();
$thread->start();
$thread->join();

echo "Summe 1–1000: {$thread->ergebnis}" . PHP_EOL;

Summe 1–1000: 500500

Synchronisation mit wait() und notify()

<?php
class ProducerThread extends Thread
{
    public ?string $nachricht = null;

    public function run(): void
    {
        sleep(1); // Simuliert Verarbeitungszeit
        $this->synchronized(function () {
            $this->nachricht = 'Hallo vom Producer!';
            $this->notify(); // Weckt wartende Threads auf
        });
    }
}

$producer = new ProducerThread();
$producer->start();

$producer->synchronized(function () use ($producer) {
    while ($producer->nachricht === null) {
        $producer->wait(); // Wartet auf notify()
    }
});

echo $producer->nachricht . PHP_EOL;
$producer->join();

Hallo vom Producer!

// Wichtig · Fallstricke

Wichtige Einschränkungen und Hinweise:

pthreads funktioniert ausschließlich in der CLI-SAPI. Ein Einsatz im Web-Server-Kontext (Apache, FPM) ist nicht möglich.
Ressourcen (z. B. Datenbankverbindungen, Datei-Handles) sind nicht thread-sicher und dürfen nicht zwischen Threads geteilt werden. Jeder Thread muss eigene Ressourcen öffnen.
Objekte, die an einen Thread übergeben werden, müssen selbst von Threaded abgeleitet sein oder werden serialisiert/deserialisiert – dabei gehen Ressourcen und Closures verloren.
Die pthreads-Erweiterung wird für PHP 8+ nicht mehr aktiv gepflegt. Die Erweiterung parallel (parallel\Runtime / parallel\Future) ist die empfohlene moderne Alternative.
Fehler in run() können den gesamten Prozess destabilisieren. Robuste Fehlerbehandlung innerhalb von run() ist daher essenziell.

Siehe auch

Threaded Worker Pool parallel\Runtime