Swoole asynchrone Programmierpraxis: Verbessern Sie die Leistung von Webdiensten um das Zehnfache

Mit der rasanten Entwicklung des Internets engagieren sich immer mehr Unternehmen in der Webentwicklung, und die Frage, wie die Leistung von Webdiensten verbessert werden kann, ist zu einem zentralen Thema geworden. In den letzten Jahren ist die asynchrone Programmierung als Technologie zur Verbesserung der Netzwerk-E/A-Effizienz allmählich populär geworden, und das Swoole-Framework ist einer der Vertreter der asynchronen Programmierung. In diesem Artikel stellen wir vor, wie man asynchrone Programmierung über das Swoole-Framework implementiert, und demonstrieren dessen signifikante Wirkung bei der Verbesserung der Leistung von Webdiensten.

1. Was ist Swoole? Swoole ist ein leistungsstarkes, asynchrones und gleichzeitiges Netzwerkkommunikations-Framework. Es erleichtert PHP-Entwicklern das Schreiben von asynchronem Code und verbessert die Effizienz und Leistung des Codes. Swoole bietet TCP/UDP/Unix-Domänen-Socket, HTTP-Server, WebSocket-Server sowie asynchrone Text-, JSON-Serialisierungs- und Deserialisierungsfunktionen. Derzeit wird Swoole von immer mehr PHP-Entwicklern bevorzugt.

2. Bei der Verwendung von Swoole sind einige Punkte zu beachten:

Um in Swoole die asynchrone Programmierung zu unterstützen, müssen wir Coroutinen aktivieren. Coroutinen sind eine einfachere Planungsmethode als Threads, da kein zusätzlicher Overhead durch Kontextwechsel und Kernel-Modus-Ressourcen entsteht.

Die Verwendung von Swoole zur Verwendung von Coroutinen ist sehr praktisch. Sie müssen lediglich den folgenden Code zur Eintragsdatei oder zum Swoole-Serverobjekt hinzufügen:

SwooleRuntime::enableCoroutine();

Auf diese Weise können Sie die von Swoole bereitgestellte Coroutine-Funktion verwenden.

2. Achten Sie auf Speicherlecks:

Wenn Sie Swoole für die asynchrone Programmierung verwenden, müssen Sie auf Speicherlecks achten. Da die Coroutine bei der asynchronen Programmierung lange auf E/A wartet, führt dies zu einer Speicherverschwendung, wenn der Speicher nicht rechtzeitig freigegeben wird.

Swoole bietet eine Methode zum Bereinigen des Coroutine-Kontexts: Coroutine::defer(). Verwenden Sie es, um den Kontext am Ende der Coroutine zu bereinigen, zum Beispiel:

SwooleCoroutineun(function () {
    echo "Coroutine Start
";
    Coroutine::defer(function () {
        echo "Coroutine End
";
    });
});

3. Achten Sie auf die Version von Swoole:

Die neue Version von Swoole wird weiterhin optimiert und verbessert, daher müssen wir sie verwenden die neueste Version. Gleichzeitig müssen Sie auf die Änderungen in jeder Version achten, um die Kompatibilität und Stabilität des Codes sicherzustellen.

3. Swoole-Praxis: Verbesserung der Webdienstleistung

Im Folgenden zeigen wir anhand eines einfachen Beispiels, wie Sie das Swoole-Framework zur Verbesserung der Webdienstleistung verwenden.

Wir erstellen zunächst eine einfache PHP-Datei server.php. Diese Datei überwacht den lokalen Port 9501 und gibt einen Hello World-String zurück:

<?php
$http = new SwooleHttpServer("0.0.0.0", 9501);

$http->on("request", function ($request, $response) {
    $response->header("Content-Type", "text/plain");
    $response->end("Hello World!
");
});

$http->start();

Verwenden Sie die Befehlszeile, um diese Datei auszuführen und besuchen Sie http://127.0.0.1: 9501/, Sie können sehen, dass Hello World ausgegeben wird.

Jetzt ändern wir den Code dieses Servers in den asynchronen Modus:

<?php
$http = new SwooleHttpServer("0.0.0.0", 9501, SWOOLE_BASE);

$http->on("request", function ($request, $response) {
    $response->header("Content-Type", "text/plain");
    $response->end("Hello World!
");
});

$http->start();

Im obigen Code haben wir den dritten Parameter hinzugefügt, der darin besteht, den SWOOLE_BASE-Modus zum Starten des Servers zu verwenden. Auf diese Weise können wir die von Swoole bereitgestellten Coroutinen, asynchronen E/A- und Event-Listening-Funktionen nutzen.

Als nächstes werden wir das Apache Bench-Tool verwenden, um die Leistung des Servers bei der Bearbeitung einer großen Anzahl von Anfragen zu testen.

Das Apache Bench-Tool kann echte HTTP-Anfragen simulieren. Wir können die gleichzeitigen Multithread-Anfragen verwenden, um den gleichzeitigen Zugriff mehrerer Benutzer auf den Server zu simulieren und die Leistung des Servers unter verschiedenen Anfragelasten zu testen.

Geben Sie im Terminal den folgenden Befehl ein, um das Apache Bench-Tool zu installieren:

# ubuntu
sudo apt-get install apache2-utils

# centos
sudo yum install httpd-tools

Verwenden Sie den folgenden Befehl, um gerade die Serverleistung zu testen:

ab -n 1000 -c 100 http://127.0.0.1:9501

In diesem Befehl verwenden wir den Parameter -n, um die Gesamtzahl darzustellen Anfragen und -c, um die Anzahl gleichzeitiger Anfragen darzustellen. Wir setzen die Gesamtzahl der Anfragen auf 1000 und die Gesamtzahl der gleichzeitigen Anfragen auf 100.

Nach Abschluss des Tests können wir die von Apache Bench gedruckten Testergebnisse sehen:

Concurrency Level:      100
Time taken for tests:   0.041 seconds
Complete requests:      1000
Failed requests:        0
Total transferred:      110000 bytes
HTML transferred:       12000 bytes
Requests per second:    24540.63 [#/sec] (mean)
Time per request:       4.075 [ms] (mean)
Time per request:       0.041 [ms] (mean, across all concurrent requests)
Transfer rate:          2624.27 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.2      0       1
Processing:     1    4   0.5      4       6
Waiting:        0    4   0.5      4       6
Total:          1    4   0.5      4       6

Percentage of the requests served within a certain time (ms)
  50%      4
  66%      4
  75%      4
  80%      4
  90%      4
  95%      5
  98%      5
  99%      5
 100%      6 (longest request)

Wir können sehen, dass bei der Verarbeitung von 1000 Anfragen durch diesen Server die durchschnittliche Antwortzeit jeder Anfrage 4,075 Millisekunden und die Anzahl der Antwortanfragen beträgt pro Sekunde Ungefähr 24540. Dieses Leistungsergebnis ist bereits sehr gut.

Als nächstes erhöhen wir die Auslastung des Servers, um zu sehen, wie sich das Swoole-Framework unter Bedingungen hoher Parallelität verhält. Wir erhöhen die Anzahl gleichzeitiger Anfragen auf 1000, das heißt:

ab -n 10000 -c 1000 http://127.0.0.1:9501

Nach Abschluss des Tests sehen wir erneut die von Apache Bench gedruckten Testergebnisse:

Concurrency Level:      1000
Time taken for tests:   2.437 seconds
Complete requests:      10000
Failed requests:        0
Total transferred:      1100000 bytes
HTML transferred:       120000 bytes
Requests per second:    4107.95 [#/sec] (mean)
Time per request:       243.651 [ms] (mean)
Time per request:       0.244 [ms] (mean, across all concurrent requests)
Transfer rate:          441.50 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    8  84.5      0     1000
Processing:     1   22  16.0     20      176
Waiting:        0   21  16.0     20      176
Total:          1   30  86.2     20     1001

Percentage of the requests served within a certain time (ms)
  50%     20
  66%     23
  75%     25
  80%     26
  90%     30
  95%     41
  98%     52
  99%     65
 100%   1001 (longest request)

Es ist ersichtlich, dass, wenn die Anzahl gleichzeitiger Anfragen 1000 erreicht, Die Antwortzeit dieses Servers beträgt nur etwa 200 ms. Im Vergleich zu synchronen Webservern mit nicht asynchroner Programmierung kann Swoole die Parallelität und Leistung erheblich verbessern.

4. Zusammenfassung

Dieser Artikel stellt das Swoole-Framework und seine Anwendung zur Verbesserung der Leistung von Webdiensten vor. Wir haben gelernt, wie man mit Swoole Coroutinen startet, auf Speicherlecks achtet und wie man die Leistung asynchroner Swoole-Server testet.

In der Praxis können wir effiziente Tools wie Swoole und Apache Bench verwenden, um die Leistung von Webdiensten zu verbessern. In Szenarien mit hoher Parallelität im Internet kann die Verwendung von Swoole für die asynchrone Programmierung die Serverleistung erheblich verbessern und den Bedarf von Unternehmen an leistungsstarken Webdiensten decken.

Das obige ist der detaillierte Inhalt vonSwoole asynchrone Programmierpraxis: Verbessern Sie die Leistung von Webdiensten um das Zehnfache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!