English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
En langage Go, le canal est le moyen de communication entre deux goroutines, et cette communication est sans verrouillage. En d'autres termes, un canal est une technologie qui permet à une goroutine d'envoyer des données à une autre goroutine. Par défaut, le canal est bidirectionnel, ce qui signifie que les goroutines peuvent envoyer ou recevoir des données via le même canal, comme indiqué dans le graphique suivant :
En langage Go, utiliser la clé chan pour créer un canal, et ce canal ne peut transmettre que des données du même type, il n'est pas autorisé à transmettre des données de types différents via le même canal.
Syntaxe :
var Channel_name chan Type
Vous pouvez également utiliser une déclaration abrégée pour créer un canal via la fonction make().
Syntaxe :
channel_name:= make(chan Type)
package main import "fmt" func main() { //Créer un canal en utilisant la clé var var mychannel chan int fmt.Println("valeur du canal: ", mychannel) fmt.Printf("type du canal: %T ", mychannel) // Utiliser la fonction make() pour créer un canal mychannel1 := make(chan int) fmt.Println("\ncanal1valeur: ", mychannel1) fmt.Printf("canal1type: %T ", mychannel1) }
Sortie :
valeur du canal: <nil> type du canal: chan int canal1valeur: 0xc0000160c0 canal1de type: chan int
En langage Go, le travail des canaux comporte deux opérations principales, l'une étant l'envoi et l'autre la réception, ces deux opérations étant appelées communication. <-La direction de l'opérateur indique s'il s'agit d'envoyer ou de recevoir des données. Dans un canal, par défaut, les opérations d'envoi et de réception bloquent jusqu'à ce que l'autre extrémité n'ait plus de données. Cela permet aux goroutines de se synchroniser les unes avec les autres sans verrou explicite ou variable conditionnelle.
Opération d'envoi :L'opération d'envoi est utilisée pour envoyer des données d'une goroutine à une autre via un canal. Comme int, float64Les valeurs comme bool peuvent être envoyées en toute sécurité et facilement via un canal, car elles sont copiées, donc il n'y a pas de risque d'accès concurrent non prévu à la même valeur. De même, les chaînes de caractères sont sécurisées car elles sont immuables. Cependant, envoyer des pointeurs ou des références (par exemple, des tranches, des ensembles map) via un canal n'est pas sécurisé, car la valeur du pointeur ou de la référence peut changer via des goroutines envoyant ou recevant en même temps, et le résultat est imprévisible. Par conséquent, lorsqu'on utilise des pointeurs ou des références dans un canal, il faut s'assurer qu'ils ne peuvent être accédés qu'une seule fois par une goroutine.
Mycanal <- element
Les instructions ci-dessus indiquent que les données (element) sont dans<-sous l'aide de l'opérateur envoyé vers le canal (Mycanal).
Opération de réception :L'opération de réception est utilisée pour recevoir les données envoyées par l'opération d'envoi.
element := <-Mycanal
Les instructions ci-dessus indiquent que cet élément reçoit des données du canal (Mycanal). Si le résultat de l'instruction reçue n'est pas disponible (nécessitant l'utilisation), c'est également une instruction valable. Vous pouvez également écrire des instructions de réception telles que :
<-Mycanal
package main import "fmt" func myfunc(ch chan int) { fmt.Println(234 + <-ch) } func main() { fmt.Println("Début de la méthode principale") //Création d'un canal l ch := make(chan int) go myfunc(ch) ch <- 23 fmt.Println("Fin de la méthode principale") }
Sortie :
Début de la méthode principale 257 Fin de la méthode principale
Vous pouvez également fermer le canal avec l'aide de la fonction close(). C'est une fonction intégrée qui définit un indicateur, indiquant qu'aucune valeur ne sera envoyée sur ce canal.
Syntaxe :
close()
Vous pouvez également utiliser une boucle itérative range pour fermer le canal. Ici, le goroutine receveur peut utiliser la syntaxe fournie pour vérifier si le canal est ouvert ou fermé :
ele, ok := <- Mycanal
Ici, si la valeur de ok est true, cela signifie que le canal est ouvert, donc vous pouvez effectuer une opération de lecture. Et si la valeur est false, cela signifie que le canal est fermé, donc l'opération de lecture ne sera pas exécutée.
//Explication du programme Go //Fermeture du canal utilisé //itération range et fermeture de la fonction package main import "fmt" func myfun(mychnl chan string) { for v := 0; v < 4; v++ { mychnl <- "w3codebox } close(mychnl) } func main() { //Création d'un canal c := make(chan string) // Utilisation de Goroutine go myfun(c) //Lorsque la valeur de ok est true, cela signifie que le canal est ouvert, il est possible d'envoyer ou de recevoir des données //Lorsque la valeur de ok est définie sur false, cela signifie que le canal est fermé for { res, ok := <-c if ok == false { fmt.Println("Fermeture du canal", ok) break } fmt.Println("Ouverture du canal", res, ok) } }
Sortie :
Ouverture du canal w3codebox true Ouverture du canal w3codebox true Ouverture du canal w3codebox true Ouverture du canal w3codebox true Fermeture du canal false
Bloquer l'envoi et la réception :Dans les canaux, lorsque des données sont envoyées dans le canal, le contrôle est bloqué dans l'instruction d'envoi jusqu'à ce qu'un autre goroutine lise les données du canal. De même, lorsque le canal reçoit des données d'un goroutine, l'instruction de lecture est bloquée jusqu'à ce qu'une autre instruction de goroutine soit exécutée.
Canal de valeur zéro : CanalLa valeur zéro est nil.
Boucle for dans les canaux : La boucle for peut parcourir les valeurs envoyées sur le canal jusqu'à ce que le canal soit fermé.
Syntaxe :
for item := range Chnl { // Instructions.. }
package main import "fmt" func main() { // Utiliser la fonction make() pour créer un canal mychnl := make(chan string) // Goroutine anonyme go func() { mychnl <- "GFG" mychnl <- "gfg" mychnl <- "Geeks" mychnl <- "w3codebox close(mychnl) } //Utiliser la boucle for for res := range mychnl { fmt.Println(res) } }
Sortie :
GFG gfg Geeks w3codebox
La longueur du canal :Dans les canaux, vous pouvez utiliserFonction len()Trouver la longueur du canal. Ici, la longueur représente le nombre de valeurs en file d'attente dans le tampon du canal.
package main import "fmt" func main() { // Utiliser la fonction make() pour créer un canal mychnl := make(chan string, 4) mychnl <- "GFG" mychnl <- "gfg" mychnl <- "Geeks" mychnl <- "w3codebox // Utiliser la fonction len() pour trouver la longueur du canal fmt.Println("La longueur du canal :", len(mychnl)) }
Sortie :
La longueur du canal : 4
Capacité du canal :Dans les canaux, vous pouvez utiliser la fonction cap() pour trouver la capacité du canal. Ici, la capacité représente la taille du tampon.
package main import "fmt" func main() { // Utiliser la fonction make() pour créer un canal mychnl := make(chan string, 4) mychnl <- "GFG" mychnl <- "gfg" mychnl <- "Geeks" mychnl <- "w3codebox // Utiliser la fonction cap() pour trouver la capacité du canal fmt.Println("La capacité du canal :", cap(mychnl)) }
Sortie :
La capacité du canal : 5
Select et la syntaxe case dans les canaux :En langage Go, la syntaxe select ressemble à une syntaxe switch sans paramètres d'entrée. En utilisant la syntaxe select dans les canaux pour exécuter une seule opération parmi plusieurs opérations fournies par les blocs case.