Écrire votre premier programme Go concurrent sur Ubuntu

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

Les choses se sont considérablement améliorées depuis. Pour Linux, il existe deux façons simples d’installer Go. Téléchargez la version binaire officielle Linux depuis la page de téléchargement de Go ou optez pour un paquet précompilé pour votre distribution Linux. La façon la plus simple d’installer Go sur Ubuntu est d’utiliser apt-get:

sudo apt-get install golang

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

package main  
  
import "fmt"  
  
func main(){  
     fmt.Println("Hello Make Tech Easier!")  
}

Depuis la v1.0 de Go, la nécessité de commandes de compilation et de liaison individuelles a été supprimée et les anciennes commandes 8g et 8l ont été remplacées par la commande go.

Pour exécuter hellomte.go, ouvrez un terminal et changez de répertoire vers le dossier contenant le fichier source, puis tapez :

go run hellomte.go

Cela compilera et exécutera le programme Go mais ne produira pas de binaire exécutable. Pour créer un binaire et ensuite l’exécuter, utilisez la commande go build :

go build hellomte.go  
./hellomte

La puissance de la concurrence

L’une des caractéristiques définissantes du langage de programmation Go est son support de la concurrence qui permet à un programme de travailler avec plusieurs tâches à la fois. Le parallélisme, qui est similaire à la concurrence, permet à un programme d’exécuter de nombreuses tâches simultanément, mais la concurrence va un peu plus loin en permettant à ces tâches séparées de communiquer et d’interagir. En conséquence, Go permet aux programmeurs d’utiliser une grande variété de conceptions concurrentes différentes, y compris des pools de travailleurs, des pipelines (où une tâche se produit après une autre), et des tâches d’arrière-plan synchrones ou asynchrones. La base de cette concurrence est la goroutine couplée avec les channels et l’instruction select de Go.

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

package main  
  
import(  
"fmt"  
"time"  
)  
  
func say(s string){  
for i := 0; i < 5; i++ {  
        fmt.Println(s)  
}  
}  
  
func main(){  
go say("Hello Make Tech Easier!")  
    fmt.Println("Dormez un peu...")  
    time.Sleep(100 * time.Millisecond)  
}

La fonction say() effectue simplement une boucle pour imprimer la chaîne (paramètre s) cinq fois. Ce qui est intéressant, c’est la façon dont cette fonction est appelée. Plutôt que d’appeler simplement say("Hello Make Tech Easier!"), le mot-clé go est placé devant l’appel de fonction. Cela signifie que la fonction sera exécutée comme une tâche séparée. Le reste de la fonction main() dort alors un peu pour donner le temps à la goroutine de se terminer.

La sortie peut vous surprendre :

Comme vous pouvez le voir, la fonction say() est exécutée en tant que goroutine et pendant qu’elle est configurée, le reste de la fonction main() continue, imprimant “Dormez un peu…” puis allant dormir. D’ici là, la goroutine est active et commence à imprimer la chaîne cinq fois. Enfin, le programme se termine une fois que la limite de temps a été atteinte.

Channels

Les goroutines peuvent communiquer en utilisant des channels. Un channel ouvre une ligne de communication entre deux parties différentes d’un programme Go. Typiquement, une fonction sera appelée en tant que goroutine et si elle a besoin de renvoyer des données (par exemple d’une opération réseau), elle peut utiliser un channel pour transmettre ces données. Si une autre partie du programme Go attend ces données, elle dormira jusqu’à ce que les données soient prêtes. Les channels sont créés à l’aide de la fonction make() et peuvent être passés en tant que paramètres aux goroutines.

Considérez ce code :

package main  
  
import(  
"fmt"  
)  
  
func say(s string, c chan int){  
var i int  
for i = 0; i < 5; i++ {  
          fmt.Println(s)  
}  
     c <- i  
}  
  
func main(){  
     c := make(chan int)  
go say("Hello Make Tech Easier!", c)  
     sts := <- c  
     fmt.Println(sts)  
}

La fonction say() est très similaire au premier exemple à l’exception que le deuxième paramètre est un channel et qu’après avoir imprimé la chaîne, le nombre d’itérations sera envoyé par le channel via la ligne de code c <- i.

La fonction principale crée un channel, démarre la fonction say() en tant que goroutine et attend ensuite que les données arrivent par le channel, sts := <- c avant d’imprimer le résultat.

Conclusion

Le langage Go a progressé de manière significative au cours des dernières années, si vous ne l’avez pas regardé récemment, peut-être que maintenant est un bon moment !