L'un des aspects les plus populaires du langage de programmation Go est sa prise en charge de premier ordre de la capacité d'un ordinateur à accomplir de nombreuses tâches simultanément. La capacité d'exécuter du code simultanément devient de plus en plus importante en programmation, car les ordinateurs passent de l'exécution d'un seul flux de code plus rapide à l'exécution de plusieurs flux simultanément. Pour réaliser des programmes qui s'exécutent plus rapidement, les programmeurs doivent les concevoir de manière à ce que chaque élément concurrent du système puisse s'exécuter indépendamment des autres.
Deux fonctionnalités de Go, Goroutines, et les canaux facilitent la concurrence lorsqu'ils sont employés ensemble. Goroutines offre le type primal de base pour cette capacité. Goroutines est moins coûteux en ce qui concerne l'espace mémoire, l'interaction inter-thread et la connectivité réseau. Ils ont également un meilleur temps de démarrage que les threads, que de nombreux langages de programmation prennent en charge. En substance, Go fait référence à Goroutines comme ce que Java et d'autres langages de programmation appellent des threads.
Qu'est-ce que Goroutines?
Une goroutine est un thread d'implémentation simple dans le Golang qui s'exécute simultanément avec le reste du programme. Goroutines est abordable lorsqu'il ressemble à des threads standards puisque le coût de création d'une goroutine est extrêmement faible. Par conséquent, ils sont largement utilisés dans Go pour la programmation concurrente. Chaque programme est constitué d'au moins une goroutine, appelée goroutine principale. La goroutine principale contrôle toutes les autres goroutines ; ainsi, si la goroutine principale se termine, toutes les autres goroutines du script le font également. La goroutine est toujours active en arrière-plan.
Exemple : Voici une illustration : vous êtes en train d'écrire quelque chose dans votre carnet et vous avez faim ; vous allez faire une pause et vous procurer de la nourriture. Puis vous recommencez à écrire. Vous jouez maintenant deux rôles (écrire et manger) dans une fenêtre temporelle considérée comme un emploi simultané. Il convient de souligner que ces deux tâches (écrire et manger) doivent encore être accomplies simultanément. Lorsque des éléments sont accomplis simultanément, on parle de parallélisme (imaginez que vous utilisez votre téléphone portable tout en grignotant des chips). La concomitance comprend l'interaction avec de nombreuses choses simultanément. Le parallélisme (effectuer plusieurs choses simultanément) en est une sous-classe (ne doit pas nécessairement être effectué en même temps) avec un certain calendrier.
Nous pouvons ajouter une goroutine en appliquant le mot-clé go à l'appel de fonction. Une fois que nous avons appliqué le mot-clé go à l'appel de fonction, nous allons définir la concurrence à la performance. Mais d'abord, identifions l'effet de l'application du mot-clé go à l'exécution. Considérons qu'il y a deux goroutines dans un programme. Le texte "package main import" sera l'entrée du programme. Dans Go, un package main import est une déclaration d'importation déclarative. La goroutine principale (first goroutine) est implicite. Lorsque nous exécutons go (f), la deuxième goroutine est formée (0). En général, lorsque nous exécutons une fonction, notre logiciel exécute chaque commande de la fonction principale avant de passer à la ligne suivante.
Nous pouvons exécuter la procédure rapidement avec une goroutine avant de passer à l'étape suivante. Par conséquent, une méthode scanln a été ajoutée ; sinon, le code se terminerait avant d'afficher tous les chiffres. Goroutines est simple à créer et peut être réalisé en grand nombre. Vous remarquerez que lorsque ce logiciel est exécuté, les goroutines semblent fonctionner de manière séquentielle plutôt que simultanée.
Avantages de Goroutines par rapport aux goroutines
Goroutines coûtent peu
Goroutines sont moins coûteux que les autres processus. La taille de la pile n'est que de quelques kilo-octets, et elle peut s'étendre ou se contracter pour répondre aux demandes du programme, contrairement aux threads, dont la taille de la pile doit être définie et est permanente.
Il y a des multiplexages Goroutines
Il existe très peu de threads du système d'exploitation auxquels ils sont multiplexés. Dans un programme comportant des centaines de goroutines, il ne peut y avoir qu'un seul processus. Le reste des goroutines est transféré au nouveau processus du système d'exploitation. Supposons qu'une goroutine de ce processus soit bloquée, par exemple lorsqu'elle demande l'intervention de l'utilisateur. Le runtime gère chacun de ces éléments, et nous, développeurs, disposons d'une API claire pour les gérer simultanément tout en étant isolés de ces subtiles complexités.
Goroutines communiquer en utilisant des canaux
Goroutines converser en utilisant des canaux. Destinés à empêcher les situations de course de se produire lorsqu'ils partagent la mémoire pertinente. Les canaux peuvent être comparés à un conduit que les goroutines utilisent pour interagir.
Que sont les canaux ?
Deux goroutines peuvent interagir l'une avec l'autre et coordonner leurs opérations par le biais de canaux. Ce logiciel imprimera continuellement "ping". Pour désigner une forme de canal, le préfixe "chan" est accompagné des éléments transmis sur le canal." Dans ce cas, nous fournissons des chaînes de caractères. Sur le canal, les messages sont envoyés et reçus à l'aide de l'opérateur. Ainsi, "ping" fait référence à l'envoi d'un "ping".
Un canal est utilisé pour garder les deux goroutines synchronisées. Avant de tenter d'envoyer un message sur le canal, le routeur attend que l'imprimante soit prête à l'accepter. Le terme pour cela est l'inhibition. Lors de la création d'un canal, un deuxième paramètre peut être utilisé pour la fonction make : c:= make (chan int, 1)
La direction du canal
Nous pouvons définir l'orientation d'une forme de canal et la paramétrer soit pour recevoir, soit pour émettre. Le signe de la méthode Pinger, par exemple, peut être modifié comme suit :
func pinger(c chan<- string)
C ne peut être envoyé que maintenant. La réception de c entraînera une erreur de code. De même, nous pouvons modifier la sortie en :
func printer(c string -chan)
Un semi-canal n'a pas ces contraintes. Un canal bidirectionnel peut être fourni à une procédure qui n'accepte que des canaux en émission ou en réception, mais pas l'inverse.
Comment lancer une goroutine ?
La méthode de lancement d'une goroutine est simple. Appliquez le mot-clé "go" à l'appel de fonction pour créer une goroutine qui s'exécutera simultanément. Nous allons ici créer une goroutine. Supposons que nous ayons un programme contenant deux fonctions : l'une est une fonction de bienvenue, et l'autre est la fonction principale.
Lorsque nous créons une nouvelle goroutine, le code welcome () s'exécutera en même temps que la fonction main(). Lorsque vous exécuterez ce programme, vous serez surpris. Ce programme ne fait que montrer le texte de l'opération principale. Qu'est-il arrivé à la première goroutine ou nouvelle goroutine que nous avons lancée ? Pour comprendre pourquoi cela se produit, nous devons d'abord connaître les deux principales caractéristiques des goroutines.
- La fonction goroutine réagit instantanément lorsque nous créons une nouvelle goroutine. En dehors des fonctions, la gestion ne dépend pas de la goroutine, elle n'attend donc pas qu'elle termine son exécution. L'exécution est transmise au bloc de code suivant après la fonction goroutine. C'est pourquoi tous les paramètres donnés par la goroutine ne sont pas pris en compte.
- Toute goroutine supplémentaire doit être exécutée en même temps que la goroutine principale. Si la goroutine principale échoue, le programme s'arrête et aucune goroutine supplémentaire ne s'exécute.
Vous comprenez maintenant pourquoi notre code n'a pas fonctionné. Après l'appel à go welcome(), le contrôle a été transféré à la ligne de code suivante avant d'attendre que la goroutine hello se termine, et la fonction principale a été sortie. La goroutine main est morte parce qu'il n'y avait pas de script à exécuter, empêchant la goroutine hello de s'exécuter.
Nous avons invoqué la technique de sommeil (time.sleep(1 * time.second)) pour mettre en pause la goroutine pendant 1 seconde. La fonction aller welcome () a maintenant suffisamment de temps pour se terminer avant que la goroutine principale ne se termine. Ce logiciel écrit d'abord le "welcome goroutine", puis attend une seconde avant d'imprimer la fonction principale. Nous utilisons la technique du sleep dans la goroutine principale pour la mettre en pause pendant un moment afin de laisser les autres goroutines se terminer.
Création de multiples Goroutines
Nous allons lancer un autre programme pour créer plusieurs goroutines. Nous pouvons commencer par créer deux goroutines qui s'exécuteront en parallèle. Ces deux goroutines sont les goroutines de nombres [go numbers()] et les goroutines d'alphabet [go alphabets ()].
La goroutine des nombres reste pendant 250 ms avant d'imprimer 1, se repose à nouveau avant d'imprimer 2, et ainsi de suite jusqu'à ce qu'elle produise 5. De même, la goroutine alphanumérique affiche la lettre de a à e, puis attend 400 millisecondes. Enfin, la goroutine principale crée les nombres entiers et les caractères alphanumériques et fait une pause, puis la goroutine principale se termine.
Erreurs fréquentes de programmation concurrente
- Absence de synchronisations lorsque cela est nécessaire
- Utilisation de time. Sleep pour effectuer les synchronisations
- Laisser les goroutines se balancer en copiant les valeurs des types du paquetage sync standard
- Appelez la synchronisation
- Groupe d'attente
- Ajouter des méthodes au mauvais endroit
- Utiliser les canaux comme des canaux de fermeture de demain, et non de la dernière goroutine émettrice fonctionnelle.
Conclusion
Dans cet article, nous avons développé un programme qui utilisait le mot clé go pour lancer une goroutine et plusieurs goroutines qui imprimaient simultanément des entiers. Après avoir lancé ce programme, nous avons établi un nouveau canal, que nous avons ensuite utilisé pour produire des nombres dans une goroutine et les transmettre à une autre goroutine afin qu'ils soient affichés à l'écran. Comme dernière démonstration de la façon de lancer une goroutine pour accélérer vos applications sur les systèmes multi-cœurs, vous avez lancé simultanément plusieurs goroutines "d'impression".
Comme nous le savons, les goroutines sont un moyen d'exécuter des tâches plus rapidement et plus efficacement. C'est l'une des procédures de déploiement proposées par AppMaster pour améliorer les fonctionnalités de votre application. Avec AppMaster, même les personnes ayant peu ou pas de connaissances en programmation peuvent accomplir des tâches qui seraient difficiles à réaliser par codage manuel.
AppMaster est une no-code plateforme qui permet de créer des applications mobiles et web ainsi qu'un backend. Fait intéressant, AppMaster crée un backend par Go à 22 000 lignes par seconde et vous pouvez accéder au code source.
