Swoole in Aktion: So nutzen Sie Coroutinen, um die Anwendungsleistung zu verbessern

Da Internetanwendungen immer komplexer werden, ist die Leistung zu einem immer wichtigeren Thema geworden. Als leistungsstarkes Netzwerkkommunikations-Framework für Coroutinen kann Swoole dieses Problem sehr gut l?sen. In diesem Artikel werden einige grundlegende Konzepte von Swoole-Coroutinen vorgestellt und anhand von Beispielen gezeigt, wie Coroutinen zur Verbesserung der Anwendungsleistung verwendet werden k?nnen.

1. Was ist eine Coroutine? Ein leichter Thread, der die Zusammenarbeit mehrerer Aufgaben in einem einzelnen Thread erreichen und frei zwischen Coroutinen wechseln kann. In Swoole k?nnen Coroutinen die Komplexit?t der asynchronen Programmierung vereinfachen. Durch Coroutinen k?nnen wir asynchronen Code genauso schreiben wie synchronen Code und verbessern so die Lesbarkeit und Wartbarkeit des Codes.

2. Grundlegende Verwendung von Coroutine

In Swoole wird die Coroutine über die Funktion swoole_coroutine_create erstellt. Der Code lautet wie folgt:

//創(chuàng)建協(xié)程
$cid = swoole_coroutine_create(function(){
    echo "Hello Coroutine
";
});

//若主線程不阻塞，則協(xié)程無法執(zhí)行

Nach dem Erstellen der Coroutine müssen Sie die Funktion swoole_event_wait verwenden, um auf die Ausführung zu warten Coroutine. Der Code lautet wie folgt:

//創(chuàng)建協(xié)程
$cid = swoole_coroutine_create(function(){
    echo "Hello Coroutine
";
});

//等待協(xié)程執(zhí)行
swoole_event_wait();

Der obige Code kann ?Hallo Coroutine“ ausgeben, was anzeigt, dass die Coroutine erfolgreich ausgeführt wurde.

In der Coroutine k?nnen Sie auch die Funktion swoole_coroutine_yield verwenden, um die aktuelle Coroutine aufzugeben und andere Coroutinen ausführen zu lassen. Der Code lautet wie folgt:

$cid1 = swoole_coroutine_create(function(){
    echo "Coroutine 1
";
    swoole_coroutine_yield();
    echo "Coroutine 1 resume
";
});

$cid2 = swoole_coroutine_create(function(){
    echo "Coroutine 2
";
    swoole_coroutine_yield();
    echo "Coroutine 2 resume
";
});

swoole_coroutine_resume($cid1);
swoole_coroutine_resume($cid2);
swoole_event_wait();

Im obigen Code werden zuerst zwei Coroutinen und dann die Funktion swoole_coroutine_resume erstellt wird verwendet, um die beiden Coroutinen zusammenzuführen. Da die Funktion swoole_coroutine_yield in der Coroutine aufgerufen wird, gibt die Coroutine jeweils ?Coroutine 1“ und ?Coroutine 2“ aus und unterbricht dann die Ausführung und gibt die CPU auf. Nachdem die Coroutine schlie?lich einen Zyklus abgeschlossen hat, holen Sie sich die CPU und geben ?Coroutine 1-Lebenslauf“ bzw. ?Coroutine 2-Lebenslauf“ aus. 3. Gemeinsame F?higkeiten von Coroutinen Definieren Sie es zuerst. Es werden zwei Aufgaben zur Aufgabenausführungsfunktion hinzugefügt, um die Ausführungszeit der Aufgabe zu simulieren. Anschlie?end werden zwei Coroutinen erstellt, und die Ausführungsergebnisse werden im Array $results gespeichert Schlie?lich wird die Funktion swoole_coroutine_wait aufgerufen, um zu warten. Die Coroutine ist abgeschlossen und das Ausführungsergebnis wird erhalten.

In Swoole kann die Funktion swoole_coroutine_system_exec verwendet werden, um Systembefehle asynchron auszuführen und die Ergebnisse zurückzugeben:

1. $tasks = [
       "task1" => function () {
           sleep(1);
           return "Task 1 Done
   ";
       },
       "task2" => function () {
           sleep(1);
           return "Task 2 Done
   ";
       },
   ];
   
   $results = [];
   
   foreach ($tasks as $name => $task) {
       $cid = swoole_coroutine_create(function () use ($name, $task, &$results) {
           $result = $task();
           $results[$name] = $result;
       });
       swoole_coroutine_resume($cid);
   }
   
   swoole_coroutine_wait();
   print_r($results);

Im obigen Code wird die Funktion async_exec zur Ausführung verwendet Systembefehle asynchron, und yield wird zum schrittweisen Lesen verwendet Holen Sie sich das Ausgabeergebnis und geben Sie schlie?lich die Zeit aus, zu der der Befehl ausgeführt wurde.

In Swoole ist die Datenbankverbindungspoolfunktion integriert, die Datenbankvorg?nge vereinfachen und die Effizienz der gleichzeitigen Ausführung über den Coroutine-Client swoole_mysql verbessern kann. Der Code lautet wie folgt:

2. function async_exec($cmd)
   {
       $fp = popen($cmd, "r");
       if ($fp) {
           while (!feof($fp)) {
               yield fread($fp, 8192);
           }
           pclose($fp);
       }
   }
   
   $s = microtime(true);
   $coroutine = async_exec('ls /');
   foreach ($coroutine as $stdout) {
       echo $stdout;
   }
   $e = microtime(true);
   echo "Time used: " . ($e - $s) . "s
   ";

Erstellen Sie im obigen Code zuerst einen Verbindungspool, verwenden Sie eine for-Schleife, um 10 MySQL-Verbindungen zu erstellen und dem Verbindungspool beizutreten, und verwenden Sie dann die Go-Funktion, um eine Coroutine zu erstellen und eine Verbindung herzustellen Aus dem Verbindungspool, um Datenbankabfragevorg?nge auszuführen, und stellen Sie die Verbindung schlie?lich wieder in den Verbindungspool ein. Der Vorteil des Verbindungspools besteht darin, dass er den durch die Erstellung und Zerst?rung von Verbindungen verursachten Overhead reduzieren und die Leistung von Datenbankoperationen verbessern kann.

4. Beispiele für die Verwendung von Swoole zur Verbesserung der Leistung von Microservice-Anwendungen

Swoole verfügt über sehr starke Coroutine-Programmierfunktionen und kann Entwicklern dabei helfen, serverseitige Anwendungen mit hoher Leistung und hoher Parallelit?t effizient zu schreiben. Im Folgenden wird am Beispiel einer Microservice-Anwendung gezeigt, wie die Coroutine-Technologie von Swoole zur Verbesserung der Anwendungsleistung verwendet werden kann.

3. Microservice-Simulationsprogramm

Zuerst erstellen wir ein einfaches Microservice-Programm mit dem folgenden Code:

$pool = new SwooleCoroutineChannel(10);
for ($i = 0; $i < 10; $i++) {
    $conn = new SwooleCoroutineMySQL();
    $conn->connect([
        'host' => '127.0.0.1',
        'user' => 'root',
        'password' => '123456',
        'database' => 'test',
    ]);
    $pool->push($conn);
}

go(function () use ($pool) {
    $conn = $pool->pop();
    $result = $conn->query('select * from users');
    //...
    $pool->push($conn);
});

Das obige Programm ist ein einfaches Microservice-Simulationsprogramm, das zwei Dienste bereitstellt: Service1 und Service2. Dienst 1 ruft Dienst 2 auf und konvertiert das Rückgabeergebnis in ein Gro?buchstabenformat. Dienst 2 verschlüsselt die Eingabezeichenfolge mit MD5 und gibt sie zurück.

Verwenden Sie Swoole, um die Coroutine-Version von Microservices zu implementieren. Der Code lautet wie folgt:

1. <?php
   //微服務(wù)1
   function service1($str)
   {
       $result = file_get_contents("http://127.0.0.1:8888/service2?str=".$str);
       return strtoupper($result);
   }
   
   //微服務(wù)2
   function service2($str)
   {
       return md5($str);
   }
   
   //路由處理
   $uri = $_SERVER['REQUEST_URI'];
   if (preg_match("/^/service1?str=(.*)$/", $uri, $match)) {
       echo service1($match[1]);
   } elseif (preg_match("/^/service2?str=(.*)$/", $uri, $match)) {
       echo service2($match[1]);
   } else {
       echo "Unknown Request: ".$uri;
   }

   Im obigen Code wird der HTTP-Coroutine-Server von Swoole verwendet, um Microservices bereitzustellen und zu antworten zum angeforderten URI. Analysieren Sie den entsprechenden Dienst und rufen Sie ihn auf. Bei der Verarbeitung von Dienst 1 wird der Dienst 2 aufgerufen und das Ergebnis zurückgegeben. Die aufrufende Methode ist jedoch über die Go-Funktion asynchron und das Schlüsselwort ?await“ wird verwendet, um auf das Ergebnis des asynchronen Aufrufs zu warten. In jeder Microservice-Implementierung werden asynchrone E/A-Operationen verwendet, um echte Netzwerk-E/A zu simulieren und die Eigenschaften von Swoole-Coroutinen besser widerzuspiegeln.

   Zusammenfassung

   Swoole bietet sehr leistungsstarke Coroutine-Programmierfunktionen, die Entwicklern beim Schreiben effizienter und leistungsstarker Netzwerkkommunikationsprogramme helfen k?nnen. Bei der Anwendungsimplementierung k?nnen Entwickler die Coroutine-Technologie verwenden, um die asynchrone Programmierung zu vereinfachen, die Effizienz der gleichzeitigen Ausführung zu verbessern usw. Im obigen Beispiel haben wir Swoole verwendet, um eine Coroutine-Version von Microservices zu implementieren, was die Leistung und Wartbarkeit der Anwendung erheblich verbesserte. Bei der tats?chlichen Implementierung müssen au?erdem geeignete asynchrone E/A-Vorg?nge, Verbindungspools und andere Technologien basierend auf den Merkmalen der Anwendung ausgew?hlt werden, um die Leistung der Anwendung weiter zu optimieren.

   Das obige ist der detaillierte Inhalt vonSwoole in Aktion: So nutzen Sie Coroutinen zur Verbesserung der Anwendungsleistung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!