Ceci est un article issu du monde Python, mais il reste applicable à tout le domaine de la programmation, bien que le multithreading nous permette de traiter les requêtes plus rapidement, mais il y a aussi un plafond, les threads verts (micro-threads) sont la solution.
Le développement logiciel multithread résout un grand nombre de problèmes, notamment pour les applications centrées sur le réseau qui nécessitent des performances exigeantes pour répondre rapidement aux utilisateurs. Malheureusement, le multithreading ne suffit pas à résoudre les problèmes à grande échelleConcurrencedes problèmes sexuels.
Résoudre ces problèmes nécessite de modifier les modèles de programmation, d’utiliser des événements asynchrones et des mécanismes basés sur des rappels. Chez Druva, nous avons créé une bibliothèque Python appelée Dhaga pour résoudre des questions à grande échelleConcurrence, tandis que le modèle de programmation ne nécessite pas de changements significatifs.
Les développeurs logiciels vivent dans un seulConcurrencemonde. Les threads sont aujourd’hui des citoyens de premier ordre, surtout lors du développement, surtout lorsque votre application effectue des opérations réseau intensives, comme le système inSync (produit de synchronisation de sécurité réseau) comme Druva. Le multithreading facilite et ordonne le flux du code de programmation pour les opérations réseau. Lorsque notre application a besoin d’améliorations ou d’améliorations de performance, elle peut l’êtreÉlasticité, nous pouvons augmenter le nombre de fils.
Mais quand il s’agit de milliers d’écaillesConcurrenceLes demandes, les discussions ne suffisent pas.
Nous avons constaté que le multithreading présente les inconvénients suivants :
1. Le client système inSync doit sauvegarder un grand nombre de fichiers sur le serveur via des appels RPC réseau. Une façon typique pour les développeurs d’accélérer les choses est d’utiliser des threads. Cependant, les performances apportées par le multithreading augmentent le coût de la mémoire et du processeur ; Les développeurs doivent maintenir un équilibre entre vitesse et nombre de threads.
2. Nos serveurs doivent gérer entre le système inSync et des milliers de clientsConcurrenceConnexions et notifications. Pour gérer efficacement les connexions, nous utilisons des threads pour traiter les requêtes. Mais le nombre croissant de clients du système inSync signifie aussi que nous devons continuer à augmenter le nombre de threads, ce qui consomme beaucoup de mémoire serveur et de CPU.
3. Notre serveur web doit gérer des milliers de requêtes HTTP parallèles. La plupart du travail concerne les sockets réseau qui reçoivent et envoient les données et les transmettent au backend du système inSync. Cela fait attendre la plupart des threads pour les opérations réseau. À la cause du problème C10K, lorsqu’il y a des milliers de requêtes synchrones vers le serveur web, générer un thread pour chaque requête est assez non évolutif (Scale).
Limitations des cadres asynchrones
De nombreux frameworks asynchrones, dont Twisted, Tornado Tornado et asyncore, peuvent aider les développeurs à s’éloigner des méthodes populaires d’utilisation des threads. Ces cadres reposent sur des sockets non bloquants et des mécanismes de rappel (similaires à Node.js). Si nous utilisons ces frameworks tels quels, les parties principales de notre code Druva devront être refactorées. Ce n’est pas ce que nous voulons faire. Le refactoring du code augmente les cycles de développement et de test, nous empêchant de répondre à nos exigences d’échelle. Étant donné que plusieurs parties du produit doivent être massives, chacun de nous devra les refactorer – d’où l’effort de doubler ou tripler.
Pour éviter de modifier autant de code, nous avons dû nous éloigner de l’utilisation directe du cadre existant. Heureusement, nous avons trouvé des outils utiles.
Comme nous voulons contrôler l’exécution du code sur les entrées/sorties réseau, nous avons besoin d’un moyen de diviser un thread en micro-threads. Nous trouvonsPetits verts。 Elle fournit une ordonnance microthread non implicite appelée coroutine co-routine. En d’autres termes. C’est utile quand vous voulez contrôler votre code en cours d’exécution. Vous pouvez créer des microthreads pour des plannings personnalisés car vous pouvez contrôler quand les greenlets produisent des pauses. C’est parfait pour nous car cela nous donne un contrôle total sur la planification de notre code.
Tornado est un framework simple de serveur web non bloquant, écrit en Python, conçu pour gérer des milliers de requêtes asynchrones. Nous utilisons son composant principal, IOLoop IOStream. IOLoop est une boucle d’événements d’E/S non bloquante sur socket ; Il utilise epoll (sous Linux) ou des files d’attente (BSD et Mac OS X), sinon il faut sélectionner (sous Windows) s’ils sont disponibles. IOStream propose des sockets non bloquants tels que des emballages pratiques pour la lecture et l’écriture. Nous déléguons toutes les opérations de socket à Tornado puis utilisons des callbacks pour déclencher des opérations de code à compléter (note banq : très similaire à Node.js mécanisme).
C’est un bon début, mais il nous en faut plus. Si nous utilisons le module ci-dessus directement dans notre code, une grande partie de notre code RPC devra changer, en planifiant RPC via les greenlets, en veillant à ce que les greenlets ne bloquent pas (si les greenlets sont bouchés, cela bloquera tout le thread et tous les autres), gérer les fonctions de rappel depuis Tornado.
Nous avons besoin d’une abstraction pour gérer et organiser les greenlets afin d’éviter de les encombrer avec des appels externes, et cette abstraction peut être massivement évolutive au-delà des threads. Cette abstraction est Dhaga, qui permet de programmer le flux de code de l’application comme une séquence synchrone traditionnelle, mais l’exécution est asynchrone.
Dhaga (de l’hindi, qui signifie thread) est un framework d’exécution pour un thread léger que nous abstraitons. La classe Dhaga est dérivée des greenlets et utilise la commutation de pile pour exécuter plusieurs flux de code dans un seul thread du système d’exploitation. Les threads d’un même système d’exploitation exécutent plusieurs dhagas en utilisant un ordonnancement collaboratif. Chaque fois qu’un dhaga attend (principalement en attendant le retour d’un appel RPC), il cède le contrôle au niveau parent (c’est-à-dire le contexte d’exécution du thread au niveau du système d’exploitation qui l’a créé). Le niveau parent programme alors un autre dhaga pour être prêt à être exécuté. L’appel RPC sera transmis au serveur web Tornado pour écrire le Socket de manière asynchrone, puis enregistrer un callback à son retour, et lorsque ce RPC reviendra, le dhaga en attente sera ajouté à la file d’exécution puis capté par le thread parent. (Note Banq : similaire à node.js principe)
Nous pouvons utiliser Dhaga au lieu des threads pour des opérations à haute latence, et nous utilisons 512 dhagas dans un seul thread lorsque le nombre de threads dépasse une limite raisonnable de débit.
|
Publié sur 06/12/2014 22:21:58
|
|
|
Publié sur 07/12/2014 17:22:55
