xvgmag

Écrire votre premier programme Go simultané sur Ubuntu


Écrire votre premier programme Go simultané sur Ubuntu / Linux

Le langage de programmation Google Go existe depuis 2009 et en 2012, la langue a atteint son statut officiel v1.0. Au cours de ces années, beaucoup de choses ont changé, y compris la façon dont la langue est installée. À ses débuts, il n'y avait pas de distributions binaires officielles et vous deviez soit construire à partir du code source, ce qui était la méthode recommandée puisque le langage changeait fréquemment, ou utiliser un paquet pré-intégré pour votre distribution Linux. À l'époque, le support Windows était limité, tout comme le support des architectures de processeur autres qu'Intel.

Les choses se sont beaucoup améliorées depuis lors. Pour Linux, il existe deux méthodes simples pour installer Go. Téléchargez la version binaire officielle de Linux depuis la page de téléchargement de Go ou optez pour un package pré-construit pour votre distribution Linux. La manière la plus simple d’installer Go on Ubuntu est d’utiliser apt-get:

sudo apt-get install golang

Une fois que Go est installé, vous pouvez commencer à développer des programmes. L'un des programmes les plus simples de Go est le programme classique «Hello World! À l’aide d’un éditeur de texte, créez un fichier appelé “hellomte.go”Avec le code court suivant:

importation principale du paquetage "fmt" func main () {fmt.Println ("Hello Make Tech Easier!")}

Depuis la version 1.0 de Go, le besoin de commandes individuelles de compilation et de liaison a été supprimé et l'ancien 8g et 8l les commandes ont été remplacées par le aller commander.

Courir hellomte.go, ouvrez un terminal et changez de répertoire dans le dossier contenant le fichier de code source, puis tapez:

allez courir hellomte.go

Cela compilera et exécutera le programme Go mais il ne produira pas de binaire exécutable. Pour créer un fichier binaire, puis l'exécuter, utilisez le aller construire commander:

allez construire hellomte.go ./hellomte

Le pouvoir de la concurrence

L'une des caractéristiques déterminantes du langage de programmation Go est sa prise en charge de la concurrence, qui permet à un programme de travailler avec plusieurs tâches à la fois. Le parallélisme, qui est similaire à la simultanéité, permet à un programme d'exécuter plusieurs tâches simultanément, mais la simultanéité va encore plus loin en permettant à ces tâches distinctes de communiquer et d'interagir. En conséquence, Go permet aux programmeurs d'utiliser toute une variété de conceptions simultanées différentes, y compris les pools de travailleurs, les pipelines (lorsqu'une tâche se produit après une autre) et les tâches d'arrière-plan synchrones ou asynchrones. La base de cette concurrence est la goroutine associé à canaux et aller sélectionner déclaration.

Voici un simple programme Go qui imprime plusieurs fois une chaîne en utilisant une goroutine simultanée:

importation principale du paquet ("fmt" "time") func say (s string) {for i: = 0; i <5; i ++ {fmt.Println (s)}} func main () {go dire ("Bonjour, rendre la technologie plus facile!") fmt.Println ("Dormir un peu…") time.Sleep (100 * time.Millisecond)}

La fonction dire() effectue simplement une boucle simple pour imprimer la chaîne (paramètre s) cinq fois. La chose intéressante est comment cette fonction est appelée. Plutôt que d'appeler dire ("Bonjour, rendre la technologie plus facile!") le mot clé aller est placé devant l'appel de fonction. Cela signifie que la fonction sera exécutée comme une tâche distincte. Le reste de la principale() fonction alors dort juste un peu pour donner du temps pour la goroutine compléter.

La sortie peut vous surprendre:

Comme vous pouvez le voir dire() la fonction est exécutée comme un goroutine et pendant qu'il est en train de configurer le reste de la principale() la fonction continue, imprimant Dors un peu… et puis aller dormir. D'ici là goroutine est actif et commence à imprimer la chaîne cinq fois. Enfin, le programme se termine une fois la limite de temporisation atteinte.

Canaux

goroutines peut communiquer en utilisant des canaux. Un canal ouvre une ligne de communication entre deux parties différentes d'un programme Go. Typiquement, une fonction sera appelée comme goroutine et si elle doit renvoyer des données (par exemple à partir d'une opération réseau), elle peut utiliser un canal pour transmettre ces données. Si une autre partie du programme Go attend ces données, celles-ci seront interrompues jusqu'à ce que les données soient prêtes. Les canaux sont créés à l'aide du faire() fonction et ils peuvent être passés en tant que paramètres à goroutines.

Considérez ce code:

package main import ("fmt") func say (s chaîne, c chan int) {var i int pour i = 0; i <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) va dire ("Hello Make Tech Easier!", c) sts: = <- c fmt.Println ( sts)}

le dire() La fonction est très similaire au premier exemple, à ceci près que le deuxième paramètre est un canal et qu'après impression de la chaîne, le nombre d'itérations sera envoyé via le canal c <- i ligne de code.

La fonction principale crée un canal, lance le dire() fonctionner comme un goroutine et attend ensuite que les données arrivent sur le canal, sts: = <- c avant d'imprimer le résultat.

Conclusion

La langue de Go a beaucoup progressé ces dernières années, si vous ne l’avez pas regardé récemment, le moment est peut-être venu!