Pratique de programmation asynchrone Swoole : améliorer dix fois les performances des services Web

Avec le développement rapide d'Internet, de plus en plus d'entreprises ont commencé à s'impliquer dans le développement Web, et comment améliorer les performances des services Web est devenu une question clé. Ces dernières années, la programmation asynchrone est progressivement devenue populaire en tant que technologie permettant d'améliorer l'efficacité des E/S du réseau, et le framework Swoole est l'un des représentants de la programmation asynchrone. Dans cet article, nous présenterons comment implémenter la programmation asynchrone via le framework Swoole et démontrerons son effet significatif sur l'amélioration des performances des services Web.

1. Qu'est-ce que Swoole

Swoole est un framework de communication réseau hautes performances, asynchrone et simultané. Il permet aux développeurs PHP d'écrire plus facilement du code asynchrone et d'améliorer l'efficacité et les performances du code. Swoole fournit un socket de domaine TCP/UDP/Unix, un serveur HTTP, un serveur WebSocket, ainsi que des fonctions de texte asynchrone, de sérialisation et de désérialisation JSON. Actuellement, Swoole est favorisé par de plus en plus de développeurs PHP.

2. Plusieurs points à noter lors de l'utilisation de Swoole

1. Ouvrez la coroutine :

Dans Swoole, afin de supporter la programmation asynchrone, nous Les coroutines doivent être activées. Les coroutines sont une méthode de planification plus légère que les threads car il n'y a pas de surcharge supplémentaire de changement de contexte et de ressources en mode noyau.

Utiliser Swoole Il est très pratique d'utiliser des coroutines Il vous suffit d'ajouter le code suivant au fichier d'entrée ou à l'objet serveur Swoole :

SwooleRuntime::enableCoroutine();

De cette façon, vous pouvez. utilisez la fonction coroutine fournie par Swoole .

2. Faites attention aux fuites de mémoire :

Lorsque vous utilisez Swoole pour la programmation asynchrone, vous devez faire attention aux fuites de mémoire. Étant donné que la coroutine dans la programmation asynchrone attendra longtemps les E/S, si la mémoire n'est pas libérée à temps, cela entraînera un gaspillage de mémoire.

Swoole fournit une méthode pour nettoyer le contexte de la coroutine : Coroutine::defer(). Utilisez-le pour nettoyer le contexte à la fin de la coroutine, par exemple :

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

3 Faites attention à la version de Swoole :

La nouvelle version de Swoole le sera. continue d'être optimisé et amélioré, nous devons donc utiliser la dernière version. Dans le même temps, vous devez faire attention aux modifications apportées à chaque version pour garantir la compatibilité et la stabilité du code.

3. Pratique Swoole : améliorer les performances des services Web

Ci-dessous, nous utilisons un exemple simple pour démontrer comment utiliser le framework Swoole pour améliorer les performances des services Web.

Nous créons d'abord un simple fichier PHP server.php. Ce fichier écoutera le port 9501 local et renverra une chaîne Hello World :

<?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();

Exécutez ceci à partir de la ligne de commande. et accédez à http://127.0.0.1:9501/, vous pouvez voir que Hello World est affiché.

Maintenant, nous changeons le code de ce serveur en mode asynchrone :

<?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();

Dans le code ci-dessus, nous avons ajouté le troisième paramètre, qui consiste à utiliser le mode SWOOLE_BASE pour démarrer le serveur . De cette façon, nous pouvons utiliser les coroutines, les fonctions d'E/S asynchrones et d'écoute d'événements fournies par Swoole.

Ensuite, nous utiliserons l'outil Apache Bench pour tester les performances du serveur lors du traitement d'un grand nombre de requêtes.

L'outil Apache Bench peut simuler de vraies requêtes HTTP Nous pouvons utiliser les requêtes simultanées multithread qu'il fournit pour simuler plusieurs utilisateurs accédant au serveur en même temps et tester les performances du serveur sous différentes requêtes. charges.

Entrez la commande suivante dans le terminal pour installer l'outil Apache Bench :

# ubuntu
sudo apt-get install apache2-utils

# centos
sudo yum install httpd-tools

Utilisez la commande suivante pour tester les performances du serveur tout à l'heure :

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

#🎜 🎜#Dans cette commande, nous utilisons le paramètre -n pour indiquer le nombre total de requêtes, et -c pour indiquer le nombre de requêtes simultanées. Nous fixons le nombre total de requêtes à 1 000 et le nombre total de requêtes simultanées à 100.

Une fois le test terminé, nous pouvons voir les résultats du test imprimés par Apache Bench :

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)

Nous pouvons voir que lorsque ce serveur traite 1000 requêtes, la moyenne de chaque requête Le temps de réponse est de 4,075 millisecondes et le nombre de demandes de réponse par seconde est d'environ 24 540. Ce résultat de performance est déjà très bon.

Ensuite, nous augmentons la charge du serveur pour voir comment le framework Swoole fonctionne dans des conditions de concurrence élevée. Nous avons augmenté le nombre de requêtes simultanées à 1000, soit :

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

Une fois le test terminé, nous voyons à nouveau les résultats du test imprimés par Apache Bench :

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)

Comme vous peut voir, dans le simultané Lorsque le nombre atteint 1000, le temps de réponse de ce serveur n'est qu'environ 200 ms. Par rapport aux serveurs Web synchrones avec programmation non asynchrone, Swoole peut considérablement améliorer la concurrence et les performances.

4. Résumé

Cet article présente le framework Swoole et son application pour améliorer les performances des services Web. Nous avons appris à utiliser Swoole pour démarrer des coroutines, à faire attention aux fuites de mémoire et à tester les performances des serveurs asynchrones Swoole.

En pratique, nous pouvons utiliser des outils efficaces tels que les outils Swoole et Apache Bench pour améliorer les performances des services web. Dans les scénarios à forte concurrence sur Internet, l'utilisation de Swoole pour la programmation asynchrone peut considérablement améliorer les performances du serveur et répondre aux besoins des entreprises en matière de services Web hautes performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!