Qu’est-ce que le langage de programmation Go et quel est son principal avantage. Pourquoi il est utile d’en apprendre les rudiments.
Il existe des dizaines de langages de programmation : certains sont plutôt anciens et peu utilisés, d’autres semblent ne pas sentir le poids des années, et d’autres encore ont été développés en récupérant au moins une partie du travail déjà effectué dans le passé.
Dans un autre article, nous avons parlé des langages machine et des différences entre les langages compilés et interprétés.
Nous avons souvent parlé du langage de programmation Go : né en 2007 et présenté officiellement en 2009, c’est un langage développé par Google qui est facile à utiliser, performant et efficace dans la phase de compilation. Des compilateurs Go sont disponibles pour les principales plateformes, notamment Windows, MacOs, Linux et généralement les systèmes de type Unix.
La syntaxe de Go ou du langage de programmation Go est proche du C, à l’exception de la déclaration des types et de l’absence de parenthèses rondes dans les constructions for et if.
En 2019, nous avons publié un billet à l’occasion des dix premières années du langage Go, rappelant également à quel point Go ou le langage de programmation Go était l’un des langages de programmation les plus prometteurs.
Le principal avantage du langage de programmation Go : la parallélisation et les goroutines
En cette deuxième décennie des années 2000, il est devenu de plus en plus urgent d’apprendre le langage Go, non pas parce qu’il a été proposé par Google, parce qu’il est maintenant utilisé pour faire fonctionner des applications web et des serveurs, parce qu’il est open source, mais plutôt parce qu’il bénéficie d’un avantage essentiel sur les autres.
Go ou le langage de programmation Go a été créé pour répondre aux besoins de la programmation concurrente et a été conçu pour optimiser les temps de compilation même sur du matériel modeste.
En informatique, la concurrence est une caractéristique selon laquelle un ensemble de processus ou de sous-processus (threads) s’exécutent en même temps. De la manière dont Go est conçu, il est possible de pousser le concept de parallélisation à l’extrême.
Les goroutines sont l’épine dorsale de Go : ce sont des constructions faciles à implémenter et en même temps très efficaces qui aident à travailler par threads. En d’autres termes, les tâches à effectuer sont réparties sur plusieurs « voies » parallèles qui peuvent fonctionner séparément sans devoir nécessairement attendre la fin d’une « tâche lente » précédente.
La parallélisation dans Go ou le langage de programmation Go peut être utilisée pour exécuter plusieurs tâches en même temps, améliorant ainsi les performances du programme et augmentant son efficacité.
C’est pourquoi le Go est utilisé pour créer différents types de programmes, notamment :
- Applications web. Ce langage peut être utilisé pour créer des serveurs Web et des services RESTful. Sa bibliothèque standard comprend tous les outils nécessaires pour travailler avec le protocole HTTP.
- Outils système. Il est utilisé pour créer des outils système tels que des compilateurs, des interpréteurs de commandes ou des utilitaires de gestion de systèmes de fichiers.
- Applications réseau. Compte tenu de ses spécificités, Go est très adapté à la création de programmes fonctionnant sur des réseaux : proxies, serveurs de chat ou programmes de transfert de fichiers.
- Microservices. Go est de plus en plus utilisé pour créer des microservices, c’est-à-dire de petits programmes indépendants qui fonctionnent ensemble pour fournir des fonctionnalités complexes. Une caractéristique importante à l’ère de l’Internet des objets ou IoT.
Pour exécuter une goroutine, il suffit d’ajouter le mot-clé go avant l’appel à la fonction que vous souhaitez paralléliser :
go maFonction()
De cette façon, la fonction appelée maFonction() est exécutée en parallèle avec le reste du programme grâce à Go ou le langage de programmation Go.
Les goroutines peuvent bien sûr communiquer entre elles et coordonner leur travail à l’aide de canaux.
Chaque programme Go ne peut avoir qu’une seule goroutine principale, appelée goroutine principale : elle est responsable du démarrage de toutes les autres goroutines et de la fin du programme lorsque toutes les autres goroutines ont terminé leur travail.
Prenez ce code Go comme exemple
Les deux goroutines task1() et task2() sont exécutées en parallèle (notez la présence de go dans les appels correspondants).
Pour simuler une tâche qui prend du temps, ils introduisent tous deux artificiellement un retard de 300 millisecondes.
Les messages à l’écran sont imprimés dans un ordre aléatoire, en fonction de la goroutine qui termine sa tâche en premier. De cette façon, le code tire parti de la parallélisation de Go ou le langage de programmation Go pour exécuter plusieurs tâches simultanément et améliorer les performances globales du programme.
package main
import (
"fmt"
"time"
)
func main() {
go task1()
go task2()
time.Sleep(time.Second)
}
func task1() {
fmt.Println("executer premier activité ...")
time.Sleep(time.Millisecond * 300)
fmt.Println("Premier activté terminer")
}
func task2() {
fmt.Println("executer deuxième activité ...")
time.Sleep(time.Millisecond * 300)
fmt.Println("Deuxième activté terminer")
}
Comme on peut le voir dans l’exemple, c’est même la deuxième tâche qui affiche en premier le message « Démarrer la deuxième tâche ».
En supprimant les deux « go » devant les appels à task1() et task2(), les tâches seront exécutées séquentiellement (vous pouvez le voir sur la sortie retournée) mais l’exécution du programme prend plus de temps car il ne peut pas bénéficier de la parallélisation.
Cet autre exemple de code Go crée un canal qui accepte des entiers et utilise ensuite deux goroutines qui envoient des données au canal. Ces informations sont ensuite imprimées à l’écran avec la dernière boucle for. Comme mentionné, les canaux Go permettent à plusieurs goroutines de communiquer entre elles et d’échanger des données.
package main
import "fmt"
func main() {
ch := make(chan int)
go func() {
ch <- 10
ch <- 20
ch <- 30
ch <- 40
}()
go func() {
ch <- 50
ch <- 60
ch <- 70
ch <- 80
}()
for i := 0; i < 8; i++ {
fmt.Println(<-ch)
}
}
Comme on peut le constater, les valeurs saisies sur le canal apparaissent toutes au moment où l’impression est demandée à l’écran.
En ce qui concerne les tests de résistance du processeur, nous avons déjà expliqué que la recherche de nombres premiers est une tâche très exigeante sur le plan informatique.
Cet exemple de code utilise des goroutines pour trouver des nombres premiers dans la plage comprise entre 1 et 100 000 : vous pouvez toutefois modifier librement la plage qui vous intéresse.
La fonction findPrimeNumbers est exécutée dans l’exemple comme une goroutine et accepte comme entrée un canal et deux entiers comme paramètres (plage de recherche).
Une boucle for est utilisée pour itérer sur les entiers dans la plage spécifiée et vérifier si chaque nombre est premier. Ce dernier contrôle est effectué en vérifiant, avec une autre boucle for, si le nombre est divisible par des nombres autres que 1 et lui-même. Si le numéro est premier, il est envoyé sur le canal Go.
Entre les dernières lignes se trouve l’appel à la fonction findPrimeNumbers qui passe le canal et la plage de nombres à examiner.
La dernière boucle for, à la fin de la procédure, examine simplement le contenu du canal et l’imprime à l’écran.
package main
import "fmt"
func findPrimeNumbers(ch chan int, start int, end int) {
for i := start; i <= end; i++ {
isPrime := true
for j := 2; j < i; j++ {
if i%j == 0 {
isPrime = false
break
}
}
if isPrime {
ch <- i
}
}
close(ch)
}
func main() {
ch := make(chan int)
go findPrimeNumbers(ch, 1, 100000)
for prime := range ch {
fmt.Println(prime)
}
}
Dans l’exemple de la figure, vous pouvez voir comment nous avons recherché les nombres premiers entre 1 et 1 000 000.
Comment essayer les exemples de code Go sous Windows
Pour essayer les exemples, il suffit de télécharger la version Windows du langage Go et de l’installer sur votre PC. Par défaut, Go ou le langage de programmation Go est chargé dans le dossier C:\Program files\Go.
Après avoir téléchargé les exemples, vous devez renommer les fichiers en remplaçant l’extension .txt par .go.
En tapant cmd dans la boîte de recherche de Windows, vous pouvez taper ce qui suit :
cd %programfiles%\Go\bin
A ce stade, pour exécuter le code Go, il suffit de taper la commande suivante :
go run formation\nomfile.go
En conclusion de ce simple excursus, vous pouvez commencer à apprendre le Go ou le langage de programmation Go à partir des nombreuses ressources d’apprentissage disponibles sur le site officiel du projet.
voir aussi : Tutoriel Python pour les débutants : Comment commencer