Swoole in Aktion: So nutzen Sie Coroutinen zur Verbesserung der Anwendungsleistung

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:

//创建协程
$cid = swoole_coroutine_create(function(){
    echo "Hello Coroutine
";
});

//若主线程不阻塞，则协程无法执行

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:

//创建协程
$cid = swoole_coroutine_create(function(){
    echo "Hello Coroutine
";
});

//等待协程执行
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.

Verarbeitung von E/A-Aufgaben

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.

Verbindungspooltechnologie

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.

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

1. <?php
   //微服务1
   function service1($str)
   {
       $result = file_get_contents("http://127.0.0.1:8888/service2?str=".$str);
       return strtoupper($result);
   }
   
   //微服务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!