So implementieren Sie Workerman zum Implementieren eines verteilten Computersystems

Ein verteiltes Computersystem bezieht sich auf ein Computermodell, das eine Gruppe von Computern als ein einziges System behandelt, um Computeraufgaben gemeinsam zu erledigen. In der Praxis können verteilte Computersysteme die Rechengeschwindigkeit erhöhen, indem sie die Anzahl der Computer erhöhen, und gleichzeitig das Problem der Verarbeitung großer Datenmengen lösen. Workerman ist ein Framework, das verteilte Computersysteme mithilfe der PHP-Sprache implementieren kann. In diesem Artikel wird erläutert, wie Workerman zum Implementieren eines einfachen verteilten Computersystems verwendet wird, und es werden Codebeispiele bereitgestellt.

1. Workerman installieren

Zuerst müssen wir Workerman installieren. Der spezifische Befehl lautet wie folgt:

composer require workerman/workerman

2. Erstellen Sie ein Serverprogramm mit dem Namen server.php. Durch Ausführen dieses Programms kann der Client Computeraufgaben an den Server senden ist dafür verantwortlich, den Rechenknoten Aufgaben zur Berechnung zuzuweisen und die Endergebnisse an den Client zurückzugeben. Das Folgende ist ein Codebeispiel von server.php:

<?php
use WorkermanWorker;

require_once __DIR__ . '/vendor/autoload.php';

$worker = new Worker('text://0.0.0.0:2346');

$worker->count = 4;

$worker->onMessage = function($connection, $data){
    $params = json_decode($data, true);

    $worker_num = $params['worker_num'];
    $task_data = $params['task_data'];

    $task_id = md5($task_data);

    $task_worker = new Task($task_id);
    $task_worker->send([
        'worker_num' => $worker_num,
        'task_data' => $task_data
    ]);
  
    $connection->send(json_encode([
        'task_id' => $task_id
    ]));
};

class Task{
    protected $task_id;
  
    protected $worker_num;

    protected $task_data;

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

    public function send($data){
        $task_data = json_encode([
            'task_id' => $this->task_id,
            'data' => $data
        ]);

        $worker_num = $data['worker_num'];
        $socket_name = "tcp://127.0.0.1:".(2347 + $worker_num);

        $client = stream_socket_client($socket_name, $errno, $errstr);
  
        fwrite($client, $task_data);
        fclose($client);
    }
}

Worker::runAll();

Im obigen Code verwenden wir den Server-Listening-Port, um darauf zu warten, dass der Client eine Aufgabe übermittelt. Wenn der Server die vom Client übermittelte Aufgabe empfängt, weist der Server die Aufgabe einem Rechenknoten zur Berechnung zu und gibt die Ergebnisse an den Client zurück.

In der Instanz der Worker-Klasse konfigurieren wir 4 Prozesse zur Bearbeitung von Clientanfragen. Im onMessage-Ereignisrückruf erhalten wir zunächst worker_num und task_data aus den vom Client übermittelten JSON-Daten, erstellen dann eine neue Task-Instanz, senden die Task an den Rechenknoten und warten auf die Rückgabe des Berechnungsergebnisses.

In der Task-Klasse speichern wir die Task-ID (task_id), die zu berechnende Knotennummer (worker_num) und die zu berechnenden Daten (task_data). Mit der Methode send() werden Aufgaben an den angegebenen Rechenknoten gesendet. Hier verwenden wir die Funktion stream_socket_client(), um einen TCP-Socket-Client für die Kommunikation mit dem angegebenen Rechenknoten zu implementieren.

Erstellen Sie ein Computerknotenprogramm

3. Als nächstes erstellen wir ein Computerknotenprogramm mit dem Namen worker.php. Das Programm führt Berechnungen durch, nachdem der Server ihm die Berechnungsaufgaben zugewiesen hat, und sendet die Ergebnisse an den Server zurück. Das Folgende ist ein Codebeispiel für worker.php:

<?php
use WorkermanWorker;

require_once __DIR__ . '/vendor/autoload.php';

$worker_num = intval($argv[1]);

$worker = new Worker("tcp://0.0.0.0:". (2347 + $worker_num));

$worker->onMessage = function($connection, $data){
    $params = json_decode($data, true);
    $task_id = $params['task_id'];

    $task_data = $params['data'];

    $result = strlen($task_data);

    $connection->send(json_encode([
        'task_id' => $task_id,
        'result' => $result
    ]));
};

Worker::runAll();

Im obigen Code verwenden wir einen TCP-Socket, um einen Port abzuhören und darauf zu warten, dass der Server Rechenaufgaben zuweist. Wenn eine Rechenaufgabe verarbeitet werden muss, erhalten wir die zu verarbeitenden Daten aus den Aufgabendaten, führen Berechnungen durch und senden die Ergebnisse an den Server.

Erstellen Sie ein Client-Programm

4. Abschließend müssen wir ein Client-Programm namens client.php erstellen, um Berechnungsaufgaben an den Server zu senden und Berechnungsergebnisse zu erhalten. Hier ist das Codebeispiel für client.php:

<?php
use WorkermanWorker;

require_once __DIR__ . '/vendor/autoload.php';

$client = stream_socket_client("tcp://127.0.0.1:2346", $errno, $errstr);

$data = [
    'worker_num' => 1,
    'task_data' => 'Workerman is a high-performance PHP socket framework'
];

$json_data = json_encode($data);

fwrite($client, $json_data);
$result = fread($client, 8192);

fclose($client);

$result_data = json_decode($result, true);

$task_id = $result_data['task_id'];

foreach(range(0,3) as $worker_num){
    $worker_client = stream_socket_client("tcp://127.0.0.1:". (2347 + $worker_num), $errno, $errstr);

    fwrite($worker_client, json_encode([
        'task_id' => $task_id,
        'worker_num' => $worker_num
    ]));

    $worker_result = fread($worker_client, 8192);

    $worker_result_data = json_decode($worker_result, true);

    if($worker_result_data['task_id'] == $task_id){
        echo "Result: " . $worker_result_data['result'] . PHP_EOL;
        break;
    }
}

Im obigen Code erstellen wir zunächst einen TCP-Socket-Client, um eine Verbindung zum Rechenknoten herzustellen. Hier wird die Funktion fread() verwendet, um die Rückgabeergebnisse der Berechnungsaufgabe vom Server zu erhalten. Anschließend senden wir task_id als Parameter an alle Rechenknoten und warten auf die Rückgabe der Ergebnisse. Anhand der Task-ID (task_id) können wir erkennen, welcher Rechenknoten das Berechnungsergebnis zurückgegeben hat. Abschließend können wir die Berechnungsergebnisse ausgeben.

Zusammenfassung

Das Obige sind die detaillierten Schritte zur Verwendung von Workerman zur Implementierung eines verteilten Computersystems, einschließlich der Erstellung von Serverprogrammen, Computerknotenprogrammen und Clientprogrammen sowie der Bereitstellung spezifischer Codebeispiele. Es ist erwähnenswert, dass die in diesem Artikel bereitgestellten Beispiele nur die Grundideen für die Verwendung von Workerman zur Implementierung verteilter Computersysteme veranschaulichen. In praktischen Anwendungen wie Lastausgleich, Aufgabenzuweisungsstrategien usw. gibt es immer noch einige Probleme. Aber all diese Probleme können gelöst werden, indem man das Workerman-Framework sorgfältig studiert und den Code anpasst.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie Workerman zum Implementieren eines verteilten Computersystems. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!