


Swoole en action?: Comment utiliser les coroutines pour améliorer les performances des applications
Nov 07, 2023 pm 03:09 PMSwoole en action?: Comment utiliser les coroutines pour améliorer les performances des applications
à mesure que les applications Internet deviennent de plus en plus complexes, les performances sont devenues un problème de plus en plus important. En tant que cadre de communication réseau hautes performances pour les coroutines, Swoole peut très bien résoudre ce problème. Cet article présentera quelques concepts de base des coroutines Swoole et prendra des exemples pour montrer comment utiliser les coroutines pour améliorer les performances des applications.
1. Qu'est-ce qu'une coroutine?? La coroutine est un thread léger qui peut réaliser une collaboration multitache sur un seul thread et peut basculer librement entre les coroutines. Dans Swoole, les coroutines peuvent simplifier la complexité de la programmation asynchrone. Grace aux coroutines, nous pouvons écrire du code asynchrone tout comme l'écriture de code synchrone, améliorant ainsi la lisibilité et la maintenabilité du code.
2. Utilisation de base de la coroutine
Dans Swoole, la coroutine est créée via la fonction swoole_coroutine_create Le code est le suivant :
//創(chuàng)建協(xié)程 $cid = swoole_coroutine_create(function(){ echo "Hello Coroutine "; }); //若主線程不阻塞,則協(xié)程無法執(zhí)行
Après avoir créé la coroutine, vous devez utiliser la fonction swoole_event_wait pour attendre l'exécution de la coroutine. coroutine. Le code est le suivant?:
//創(chuàng)建協(xié)程 $cid = swoole_coroutine_create(function(){ echo "Hello Coroutine "; }); //等待協(xié)程執(zhí)行 swoole_event_wait();
Le code ci-dessus peut afficher "Bonjour Coroutine", indiquant que la coroutine a été exécutée avec succès.
Dans la coroutine, vous pouvez également utiliser la fonction swoole_coroutine_yield pour abandonner la coroutine actuelle et laisser d'autres coroutines s'exécuter :
$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();
Dans le code ci-dessus, deux coroutines sont d'abord créées, puis la fonction swoole_coroutine_resume. est utilisé pour fusionner les deux coroutines. Chaque coroutine reprend l'exécution respectivement Puisque la fonction swoole_coroutine_yield est appelée dans la coroutine, la coroutine affichera respectivement "Coroutine 1" et "Coroutine 2", puis toutes deux suspendront l'exécution et abandonneront le CPU. Enfin, une fois que la coroutine a terminé un cycle, récupérez le processeur et affichez respectivement "Coroutine 1 CV" et "Coroutine 2 CV".
3. Compétences communes des coroutines
Gestion des taches simultanées- Dans Swoole, la fonction swoole_coroutine_wait peut être utilisée pour implémenter l'exécution simultanée et la synchronisation de plusieurs coroutines. Le code est le suivant?:
$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);
Dans le code ci-dessus. , définissez-le d'abord. Deux taches sont créées. Sleep(1) est ajouté à la fonction d'exécution de tache pour simuler le temps d'exécution de la tache. Ensuite, une boucle foreach est utilisée pour créer deux coroutines, les résultats de l'exécution sont enregistrés dans le tableau $results et. enfin la fonction swoole_coroutine_wait est appelée pour attendre La coroutine est terminée et le résultat de l'exécution est obtenu.
Traitement des taches IO- Dans Swoole, la fonction swoole_coroutine_system_exec peut être utilisée pour exécuter des commandes système de manière asynchrone et renvoyer les résultats. Le code est le suivant :
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 ";
Dans le code ci-dessus, la fonction async_exec est utilisée pour exécuter. Les commandes système sont asynchrones et le rendement est utilisé pour lire étape par étape. Obtenez le résultat de sortie et enfin affichez l'heure à laquelle la commande a été exécutée.
Technologie de pool de connexions- Dans Swoole, la fonction de pool de connexions à la base de données est intégrée, ce qui peut simplifier les opérations de base de données et améliorer l'efficacité de l'exécution simultanée via le client coroutine swoole_mysql. Le code est le suivant?:
$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); });
Dans le code ci-dessus, créez d'abord un pool de connexions, utilisez une boucle for pour créer 10 connexions MySQL et rejoignez le pool de connexions, puis utilisez la fonction go pour créer une coroutine et supprimez une connexion du pool de connexions pour effectuer des opérations de requête de base de données, et enfin remettre la connexion dans le pool de connexions. L'avantage du pool de connexions est qu'il peut réduire la surcharge provoquée par la création et la destruction de connexions et améliorer les performances des opérations de base de données.
4. Exemples d'utilisation de Swoole pour améliorer les performances des applications de microservices
Swoole possède de très fortes capacités de programmation de coroutines et peut aider les développeurs à écrire efficacement des applications c?té serveur hautes performances et à haute concurrence. Ce qui suit prend comme exemple une application de microservice pour montrer comment utiliser la technologie coroutine de Swoole pour améliorer les performances des applications.
Programme de simulation de microservices- Tout d'abord, nous créons un programme de microservice simple avec le code suivant?:
<?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; }
Le programme ci-dessus est un programme de simulation de microservice simple qui fournit deux services?: service1 et service2. Le service 1 appellera le service 2 et convertira le résultat renvoyé au format majuscule. Le service 2 cryptera la cha?ne d'entrée avec MD5 et la renverra.
Utilisez Swoole pour implémenter la version coroutine des microservices- Utilisez Swoole pour implémenter la version coroutine des microservices. Le code est le suivant?:
<?php $http = new SwooleHttpServer("0.0.0.0", 8888); $http->on("request", function ($request, $response) { $uri = $request->server['request_uri']; if (preg_match("/^/service1?str=(.*)$/", $uri, $match)) { $result = go(function () use ($match) { $str = $match[1]; $result = await service2($str); return strtoupper($result); }); $response->end($result); } elseif (preg_match("/^/service2?str=(.*)$/", $uri, $match)) { $result = go(function () use ($match) { $str = $match[1]; $result = await service2($str); return $result; }); $response->end($result); } else { $response->end("Unknown Request: ".$uri); } }); $http->start(); async function service1($str) { $result = await service2($str); return strtoupper($result); } async function service2($str) { //模擬異步IO操作 usleep(1000000); return md5($str); }
Dans le code ci-dessus, le serveur coroutine HTTP de Swoole est utilisé pour fournir des microservices et répondre. à l'URI demandé, analyser et appeler le service correspondant. Dans le traitement du service 1, le service service 2 est appelé et le résultat est renvoyé, mais la méthode appelante est asynchrone via la fonction go et le mot clé wait est utilisé pour attendre le résultat de l'appel asynchrone. Dans chaque implémentation de microservice, les opérations d'E/S asynchrones sont utilisées pour simuler les E/S du réseau réel afin de mieux refléter les caractéristiques des coroutines Swoole.
Résumé
Swoole fournit des capacités de programmation de coroutines très puissantes, qui peuvent aider les développeurs à écrire des programmes de communication réseau efficaces et performants. Lors de la mise en ?uvre d'applications, les développeurs peuvent utiliser la technologie coroutine pour simplifier la programmation asynchrone, améliorer l'efficacité de l'exécution simultanée, etc. Dans l'exemple ci-dessus, nous avons utilisé Swoole pour implémenter une version coroutine des microservices, ce qui a considérablement amélioré les performances et la maintenabilité de l'application. Dans la mise en ?uvre réelle, il est également nécessaire de sélectionner les opérations d'E/S asynchrones, les pools de connexions et autres technologies appropriés en fonction des caractéristiques de l'application pour optimiser davantage les performances de l'application.
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!

Outils d'IA chauds

Undress AI Tool
Images de déshabillage gratuites

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
échangez les visages dans n'importe quelle vidéo sans effort grace à notre outil d'échange de visage AI entièrement gratuit?!

Article chaud

Outils chauds

Bloc-notes++7.3.1
éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Comparaison des performances de différents frameworks Java : Traitement des requêtes API REST : Vert.x est le meilleur, avec un taux de requêtes de 2 fois SpringBoot et 3 fois Dropwizard. Requête de base de données?: HibernateORM de SpringBoot est meilleur que l'ORM de Vert.x et Dropwizard. Opérations de mise en cache?: le client Hazelcast de Vert.x est supérieur aux mécanismes de mise en cache de SpringBoot et Dropwizard. Cadre approprié?: choisissez en fonction des exigences de l'application. Vert.x convient aux services Web hautes performances, SpringBoot convient aux applications gourmandes en données et Dropwizard convient à l'architecture de microservices.

Selon les benchmarks, pour les petites applications hautes performances, Quarkus (démarrage rapide, mémoire faible) ou Micronaut (TechEmpower excellent) sont des choix idéaux. SpringBoot convient aux grandes applications full-stack, mais a des temps de démarrage et une utilisation de la mémoire légèrement plus lents.

Causes et solutions pour les erreurs Lors de l'utilisation de PECL pour installer des extensions dans un environnement Docker Lorsque nous utilisons un environnement Docker, nous rencontrons souvent des maux de tête ...

La meilleure fa?on de générer des nombres aléatoires dans Go dépend du niveau de sécurité requis par votre application. Faible sécurité?: utilisez le package math/rand pour générer des nombres pseudo-aléatoires, adaptés à la plupart des applications. Haute sécurité?: utilisez le package crypto/rand pour générer des octets aléatoires cryptographiquement sécurisés, adaptés aux applications qui nécessitent un caractère aléatoire plus élevé.

Les techniques efficaces pour optimiser les performances multithread C++ incluent la limitation du nombre de threads pour éviter les conflits de ressources. Utilisez des verrous mutex légers pour réduire les conflits. Optimisez la portée du verrou et minimisez le temps d’attente. Utilisez des structures de données sans verrouillage pour améliorer la simultanéité. évitez les attentes occupées et informez les threads de la disponibilité des ressources via des événements.

Le cycle de vie de la coroutine Go peut être contr?lé des manières suivantes : Créer une coroutine : utilisez le mot-clé go pour démarrer une nouvelle tache. Terminez les coroutines?: attendez que toutes les coroutines soient terminées, utilisez sync.WaitGroup. Utilisez les signaux de fermeture de canal. Utilisez le contexte context.Context.

Lors du développement d'applications hautes performances, le C++ surpasse les autres langages, notamment dans les micro-benchmarks. Dans les benchmarks macro, les mécanismes de commodité et d'optimisation d'autres langages tels que Java et C# peuvent mieux fonctionner. Dans des cas pratiques, C++ fonctionne bien dans le traitement d'images, les calculs numériques et le développement de jeux, et son contr?le direct de la gestion de la mémoire et de l'accès au matériel apporte des avantages évidents en termes de performances.

Comment utiliser les coroutines Go pour implémenter le traitement parallèle ? Créez une coroutine pour calculer la séquence de Fibonacci en parallèle. Les coroutines transfèrent les données via des canaux pour réaliser un calcul parallèle. La coroutine principale re?oit et traite les résultats des calculs parallèles.
