Swooles Coroutine- und asynchrone Programmierpraxis

Mit der kontinuierlichen Entwicklung von Internetanwendungen ist eine hohe Parallelität zu einer Herausforderung geworden, der sich jeder Entwickler stellen muss. Um mit hoher Parallelität zurechtzukommen, verwenden Front-End-Studenten Technologien wie Front-End-Anzeige und asynchrone E/A, während Back-End-Studenten Coroutinen und asynchrone Programmiertechnologien verwenden. Unter anderem ist Swoole ein Coroutine-Framework in der PHP-Sprache. Es nutzt Coroutinen und asynchrone Programmierideen, um die Entwicklung und das Debuggen bei hoher Parallelität zu vereinfachen und Entwicklern ein besseres Entwicklungserlebnis zu bieten.

1. Die Konzepte von Coroutinen und asynchroner Programmierung

Das Verständnis von Coroutinen kann einfach als „Mikro-Threads“ verstanden werden, die ähnliche Konzepte wie Threads sind, sich jedoch vom Thread-Switching-Mechanismus unterscheiden. Coroutinen sind keine Threads des Betriebssystemkernels, sondern werden innerhalb des Benutzerprozesses geschaltet. Durch die Verwendung von Coroutinen kann ein nicht blockierendes Warten durchgeführt werden, während gleichzeitig die CPU-Auslastung verbessert und die Anzahl der Kontextwechsel verringert wird.

Asynchrone Programmierung ist eine „ereignisgesteuerte“ Programmiermethode. Ihr Hauptmerkmal ist die Verwendung nicht blockierender E/A, wodurch die durch E/A-Blockierungswartezeiten verursachte Thread-Wartezeit vermieden und die Parallelität erhöht wird. Wenn bei der asynchronen Programmierung ein Ereignis abgeschlossen ist, benachrichtigt das Programm den entsprechenden Thread, um die Verarbeitung fortzusetzen, anstatt den Thread blockieren und warten zu lassen. Bei der asynchronen Programmierung werden Rückrufe zur Verarbeitung asynchroner Vorgänge verwendet, um den Wechsel zwischen Coroutinen zu bewältigen und die gleichzeitigen Verarbeitungsfähigkeiten des Programms zu verbessern.

2. Swooles Coroutine- und asynchrone Programmierpraxis

1. Coroutine

Swoole-Coroutine simuliert und implementiert den Coroutine-Mechanismus in Prozessen und Threads in der PHP-Sprachumgebung. In der Coroutine von Swoole können Sie den Coroutine-Scheduler verwenden, um die laufende Steuerung von PHP an die Coroutine zu übergeben, wodurch Thread-Wartezeiten durch E/A-Blockierungswartezeiten vermieden und die Betriebseffizienz verbessert werden. Coroutinen realisieren den Wechsel zwischen Coroutinen mithilfe der Funktionen swoole_coroutine_create() und swoole_coroutine_resume(). Gleichzeitig stellt Swoole ereignisgesteuerte Funktionen wie swoole_event_add(), swoole_event_set() usw. bereit, was das Coroutine-Programmiermodell erheblich vereinfacht.

Im Folgenden werden wir die Verwendung der Swoole-Coroutine Schritt für Schritt durch Code-Übungen verstehen.

1) Installieren Sie die Swoole-Erweiterung

Zuerst müssen wir die Swoole-Erweiterung installieren, um die Entwicklung der Swoole-Coroutine zu erreichen. Die Swoole-Erweiterung kann über den folgenden Befehl installiert werden:

$ pecl install swoole

2) Erstellen Sie eine Coroutine

Als nächstes müssen wir eine Coroutine erstellen und die Funktion swoole_coroutine_resume() verwenden, um die Coroutine auszuführen. Der spezifische Code lautet wie folgt:

<?php
function test_coroutine(){
    echo "Start coroutine
";
    swoole_coroutine::sleep(1);
    echo "End coroutine
";
}
swoole_coroutine::create("test_coroutine");
echo "Main func end
";

Wir können sehen, dass die Funktion swoole_coroutine_create() im Code zum Erstellen einer Coroutine verwendet wird und eine test_coroutine()-Funktion übergeben wird. Zu diesem Zeitpunkt wurde die Coroutine noch nicht ausgeführt. Nach dem Aufruf von swoole_coroutine_create() übermittelt das System die Coroutine an den Coroutine-Scheduler und wartet auf die Ausführung. Anschließend wird durch den Aufruf der Funktion swoole_coroutine_resume() die Funktion test_coroutine() ausgeführt und die entsprechenden Ergebnisse ausgegeben.

3) Wechseln zwischen Coroutinen

In der Coroutine können wir auch die Funktion swoole_coroutine_yield() verwenden, um Coroutinen manuell zu wechseln. Der spezifische Implementierungscode lautet wie folgt:

<?php
function test_coroutine(){
    for ($i=0; $i<5; $i++){
        echo "Coroutine $i
";
        swoole_coroutine::yield();
    }
}
$c = swoole_coroutine::create("test_coroutine");
for ($i=0; $i<5; $i++){
    swoole_coroutine::resume($c);
}

Mit dem obigen Code haben wir eine Coroutine erstellt und die Funktion test_coroutine() fünfmal durchlaufen, um die Coroutinennummer auszugeben. Verwenden Sie die Funktion swoole_coroutine_yield(), um Coroutinen manuell zu wechseln, sodass mehrere Coroutinen fair verarbeitet werden können.

2. Asynchrone Programmierung

Swooles asynchrone Programmierung wird hauptsächlich basierend auf ereignisgesteuerten Funktionen wie Woole_event_add(), Swoole_event_set() und Swoole_event_wait() implementiert. Insbesondere werden die Funktionen „woole_event_add()“ und „swoole_event_set()“ verwendet, um I/O-Ereignisse zur Ereignisschleife hinzuzufügen, während die Funktion „swoole_event_wait()“ zum Starten der Ereignisschleife verwendet wird.

Im Folgenden werden wir die asynchrone Programmierpraxis von Swoole Schritt für Schritt anhand des Codes verstehen.

1) Installieren Sie die Swoole-Erweiterung

Zuerst müssen wir die Swoole-Erweiterung installieren, um die Entwicklung der asynchronen Swoole-Programmierung zu ermöglichen. Die Swoole-Erweiterung kann über den folgenden Befehl installiert werden:

$ pecl install swoole

2) Asynchrone TCP-Kommunikation

In Swoole kann die asynchrone TCP-Kommunikation zwischen Systemen über swoole_client und swoole_server unterstützt werden. Bei der asynchronen TCP-Kommunikation müssen wir SwooleServer verwenden, um einen TCP-Dienst zu starten, und auf der Serverseite die Funktion swoole_event_add() verwenden, um dem Dienst ein E/A-Ereignis hinzuzufügen. Der Nachrichtensender verwendet swoole_client, um asynchrone Kommunikation zu implementieren. Der spezifische Implementierungscode lautet wie folgt:

<?php
//异步TCP服务端
$serv = new swoole_server("127.0.0.1", 9501);
$serv->set(array(
    'worker_num' => 4,
    'daemonize' => false,
));

$serv->on('Receive', function ($serv, $fd, $from_id, $data) {
    $serv->send($fd, 'Server: '.$data);
    $serv->close($fd);
});

$serv->start();

<?php
//异步TCP客户端
$client = new swoole_client(SWOOLE_SOCK_TCP, SWOOLE_SOCK_ASYNC);

$client->on("connect", function($cli) {
    $cli->send("hello world
");
});

$client->on("receive", function($cli, $data){
    echo "Received: ".$data."
";
});

$client->on("error", function($cli){
    echo "Connect failed
";
});

$client->on("close", function($cli){
    echo "Connection closed
";
});

$client->connect('127.0.0.1', 9501);

Mit dem obigen Code haben wir ein Beispiel für asynchrone TCP-Kommunikation implementiert. Wenn der Client eine Nachricht sendet, empfängt der Server die Nachricht und gibt das Verarbeitungsergebnis zurück.

Zusammenfassung:

Dieser Artikel erklärt hauptsächlich die Praxis von Swoole-Coroutinen und asynchroner Programmierung. Bei der Entwicklung hochgradig gleichzeitiger Internetanwendungen kann der Einsatz von asynchroner Programmierung und Coroutinen die Systemleistung effektiv verbessern und die Entwicklungseffizienz verbessern. Das Swoole-Framework bietet gute Unterstützung für die Coroutine- und asynchrone Programmierung und ermöglicht es Programmierern, auf einfache Weise effiziente asynchrone Verarbeitung und Coroutine-Planung zu implementieren und so die gleichzeitigen Verarbeitungsfähigkeiten des Systems zu verbessern.

Das obige ist der detaillierte Inhalt vonSwooles Coroutine- und asynchrone Programmierpraxis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!