Yar_Concurrent_Client — Klasse · PHP-Referenz

Signatur

class Yar_Concurrent_Client

Beschreibung

Yar_Concurrent_Client ist Teil der Yar-PECL-Erweiterung und erlaubt es, mehrere RPC-Aufrufe an unterschiedliche oder gleiche Endpunkte parallel (nebenläufig) abzusetzen. Anstatt Anfragen nacheinander zu senden und jeweils auf die Antwort zu warten, werden alle registrierten Aufrufe gebündelt und asynchron über cURL multi-handle ausgeführt – was die Gesamtlaufzeit bei mehreren Diensten erheblich reduziert.

Der typische Ablauf besteht darin, mit der statischen Methode Yar_Concurrent_Client::call() mehrere Anfragen zu registrieren, dabei jeweils einen Erfolgs- und einen optionalen Fehler-Callback anzugeben, und anschließend mit Yar_Concurrent_Client::loop() die Ausführung zu starten. Die Callbacks werden aufgerufen, sobald die jeweilige Antwort eingegangen ist.

Diese Klasse eignet sich besonders für Microservice-Architekturen oder Aggregationsschichten, in denen mehrere unabhängige Dienste gleichzeitig abgefragt werden müssen, z. B. das parallele Abrufen von Nutzer-, Produkt- und Lagerbestandsdaten in einem einzigen Request-Zyklus.

Alle Methoden sind statisch. Die Klasse selbst wird nicht instanziiert; stattdessen dient sie als statischer Namespace für die Nebenläufigkeits-API von Yar.

Beispiele

Parallele Aufrufe mehrerer RPC-Dienste

<?php
// Erfolgs-Callback: wird aufgerufen, wenn ein Dienst antwortet
$callback = function ($ret, $callinfo) {
    echo "Dienst '{$callinfo['method']}' antwortete: ";
    var_dump($ret);
};

// Fehler-Callback: wird bei einem Übertragungsfehler oder RPC-Fehler aufgerufen
$errorCallback = function ($type, $error, $callinfo) {
    echo "Fehler bei '{$callinfo['method']}': {$error}\n";
};

// Anfrage 1 an Dienst A registrieren
Yar_Concurrent_Client::call(
    'http://dienst-a.example.com/rpc/',
    'getUserInfo',
    [42],
    $callback,
    $errorCallback
);

// Anfrage 2 an Dienst B registrieren
Yar_Concurrent_Client::call(
    'http://dienst-b.example.com/rpc/',
    'getProductList',
    ['category' => 'electronics'],
    $callback,
    $errorCallback
);

// Anfrage 3 an Dienst C registrieren
Yar_Concurrent_Client::call(
    'http://dienst-c.example.com/rpc/',
    'getStockLevel',
    [101],
    $callback,
    $errorCallback
);

// Alle Anfragen nebenläufig ausführen
Yar_Concurrent_Client::loop();

echo "Alle Anfragen abgeschlossen.\n";

Dienst 'getUserInfo' antwortete: ... Dienst 'getProductList' antwortete: ... Dienst 'getStockLevel' antwortete: ... Alle Anfragen abgeschlossen.

Globale Callbacks über loop() definieren

<?php
// Anfragen ohne eigene Callbacks registrieren
Yar_Concurrent_Client::call(
    'http://dienst-a.example.com/rpc/',
    'ping',
    []
);

Yar_Concurrent_Client::call(
    'http://dienst-b.example.com/rpc/',
    'ping',
    []
);

// Globalen Erfolgs- und Fehler-Callback direkt in loop() übergeben
Yar_Concurrent_Client::loop(
    function ($ret, $callinfo) {
        echo "Antwort von '{$callinfo['uri']}': ";
        var_dump($ret);
    },
    function ($type, $error, $callinfo) {
        echo "Fehler: {$error}\n";
    }
);

Antwort von 'http://dienst-a.example.com/rpc/': ... Antwort von 'http://dienst-b.example.com/rpc/': ...

// Wichtig · Fallstricke

Voraussetzungen: Die Yar-Erweiterung muss mit cURL-Unterstützung kompiliert sein (--enable-yar bzw. yar.enable_persistent_connection in php.ini). Ohne cURL multi-handle wird Nebenläufigkeit nicht unterstützt.

Reihenfolge der Callbacks: Die Callbacks werden nicht zwingend in der Reihenfolge aufgerufen, in der die Anfragen registriert wurden – sie werden aufgerufen, sobald die jeweilige Antwort eintrifft.

Kein Shared State: Da alle Methoden statisch sind, gelten registrierte Anfragen global für den aktuellen Prozess. Nach einem loop()-Aufruf wird die interne Anfragenliste geleert. Mehrere loop()-Aufrufe ohne dazwischenliegende call()-Registrierungen bewirken nichts.

Timeout-Konfiguration: Timeouts können über Yar_Client-Optionen oder global über yar.timeout in der php.ini gesteuert werden. Bei produktiven Systemen sollten Timeouts immer explizit gesetzt werden, um Hänger zu vermeiden.

Siehe auch

Yar_Client Yar_Server Yar_Client_Exception Yar_Server_Exception