Concurrence (Goroutines) en Go

Go语言提供了称为Goroutines的特殊功能。Goroutine是一种函数或方法，可与程序中存在的任何其他Goroutine一起独立且同时执行。换句话说，每个Go语言中同时执行的活动称为Goroutines，您可以将Goroutine视为轻量级线程。与线程相比，创建Goroutines的成本非常小。每个程序至少包含一个Goroutine，并且该Goroutine被称为主Goroutine。如果主Goroutine终止，则所有Goroutine在主Goroutine之下运行，那么程序中存在的所有goroutine也将终止；Goroutine始终在后台运行。

如何创建Goroutine？

您只需使用go关键字作为函数或方法调用的前缀，即可创建自己的Goroutine，如以下语法所示：

Syntaxe :

func name() {
//　Instructions
}
//　在函数名前面，使用go关键字
go name()

package main　
　　
import "fmt"
　　
func display(str string) {　
　　　　for w := 0;　6; w++　{　
　　　　　　　　fmt.Println(str)　
　　　　}　
}　
　　
func main() {　
　　
　　　　//　Appel de Goroutine　
　　　　go display("Bienvenue")　
　　
　　　　//正常调用函数
　　　　display("oldtoolbag.com)　
}

Sortie :

oldtoolbag.com
oldtoolbag.com
oldtoolbag.com
oldtoolbag.com
oldtoolbag.com
oldtoolbag.com

在上面的示例中，我们仅创建了display()函数，然后以两种不同的方式调用此函数，第一种是Goroutine，即go display("Welcome")，另一种是常规调用函数，即display("w3codebox)

但是您可能发现问题了，它只显示调用普通函数的结果，而不显示Goroutine的结果，因为执行新的Goroutine时，Goroutine调用会立即返回。它不像普通函数那样等待Goroutine完成执行，它们总是在Goroutine调用后一直前进到下一行，并忽略Goroutine返回的值。因此，为了正确执行Goroutine，我们对程序进行了一些更改，如以下代码所示：

修改后的Goroutine示例：

package main　
　　
import (　
　　　　"fmt"
　　　　"time"
)　
　　
func display(str string) {　
　　　　for w := 0;　6; w++　{　
　　　　　　　　time.Sleep(1　*　time.Second)　
　　　　　　　　fmt.Println(str)　
　　　　}　
}　
　　
func main() {　
　　
　　　　//　Appel de Goroutine　
　　　　go display("Bienvenue")　
　　
　　　　//Appel de fonction normale
　　　　display("w3codebox)　
}

Sortie :

Bienvenue
w3codebox
w3codebox
Bienvenue
Bienvenue
w3codebox
w3codebox
Bienvenue
Bienvenue
w3codebox
w3codebox

Nous avons ajouté la méthode Sleep() dans le programme, qui fait que la Goroutine principale reste inactive pendant l'exécution de la nouvelle Goroutine1secondes de sommeil1secondes, affichez l'accueil à l'écran, puis1secondes de la Goroutine principale redémarre et exécute ses opérations avant de se terminer. Ce processus continue jusqu'à ce que la valeur de z soit <6Après quoi la Goroutine principale se termine. Ici, la Goroutine et la fonction normale travaillent en même temps.

Avantages des Goroutines

• Les Goroutines sont moins coûteuses que les threads.

• Les Goroutines sont stockées dans un pile, et la taille de ce pile peut augmenter et diminuer selon les besoins du programme. Cependant, dans un thread, la taille du pile est fixe.

• Les Goroutines peuvent communiquer via des canaux, et ces canaux sont spécialement conçus pour éviter les conflits lors de l'accès aux mémoires partagées par les Goroutines.

• Supposons qu'un programme ait un thread, et que ce thread ait de nombreuses Goroutines associées. Si une Goroutine bloque en raison des besoins en ressources, toutes les autres Goroutines sont attribuées à un nouveau thread OS créé. Tous ces détails sont cachés au programmeur.

Goroutine anonyme

En langage Go, vous pouvez également démarrer une Goroutine pour une fonction anonyme, autrement dit, vous pouvez simplement créer une Goroutine anonyme en utilisant le mot-clé go comme préfixe de la fonction, comme le montre la syntaxe suivante :

Syntaxe :

//Appel de fonction anonyme
go func (parameter_list){
　　　　//　Instructions
)(arguments)

package main　
　　
import (　
　　　　"fmt"
　　　　"time"
)　
　　
func main() {　
　　
　　　　fmt.Println("Bienvenue !! à la fonction principale")　
　　
　　　　//Création d'une Goroutine anonyme
　　　　go func() {　
　　
　　　　　　　　fmt.Println("Bienvenue !! à oldtoolbag.com)　
　　　　})　
　　
　　　　time.Sleep(1　*　time.Second)　
　　　　fmt.Println("Au revoir !! à la fonction principale")　
}

Sortie :

Bienvenue !! à la fonction principale
Bienvenue !! à oldtoolbag.com
Au revoir !! à la fonction principale