English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Tutoriel de base Golang

Instructions de contrôle Golang

Fonction & Méthode Golang

Structure Golang

Coupe & Tableau Golang

Chaine de caractères (String) Golang

Pointeur Golang

Interface Golang

Concurrence Golang

Exceptions (Error) Golang

Autres outils Golang

Channel (Channel) du langage Go

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 :

Création d'un canal

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

Envoyer et recevoir des données via un canal

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.

  1. 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).

  2. 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

Fermeture du canal

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

Remarque importante

  • 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.