Qu'est-ce qu'une chaîne en langage Go ?

Le canal dans le langage Go est une structure de données spéciale qui peut être utilisée pour mettre en œuvre la communication et la synchronisation entre différentes goroutines. Il s'agit de l'un des composants essentiels du modèle de concurrence du langage Go et de la primitive de concurrence la plus importante du langage Go.

Alors, pourquoi la chaîne est-elle si importante ? Parce que le modèle de concurrence du langage Go est essentiellement basé sur le modèle CSP (Communicating Sequential Processes), et que le canal est le canal dans le modèle CSP, son rôle est similaire à un canal, utilisé pour transférer des données entre différentes goroutines, ce qui rend les goroutines La synchronisation des données devient très pratique.

En langage Go, vous pouvez créer un canal à l'aide de la fonction make intégrée et spécifier le type d'élément de canal et la taille du tampon (si nécessaire) :

ch := make(chan int)        // 创建一个无缓冲的 channel
ch2 := make(chan string, 10)  // 创建一个带有缓冲区的 string 类型的 channel，缓冲区大小为 10

Vous pouvez le voir si la taille du tampon n'est pas spécifiée , le canal est sans tampon. Cela signifie que lorsqu'une goroutine lit les données d'un canal sans tampon, elle se bloque jusqu'à ce qu'une autre goroutine écrive des données sur le canal. De manière correspondante, lorsqu'une goroutine écrit des données sur un canal sans tampon, elle se bloque jusqu'à ce qu'une autre goroutine lise les données du canal.

En revanche, un canal tamponné peut effectuer des opérations d'écriture non bloquantes lorsque le tampon n'est pas plein, et ne bloquera que lorsque le tampon est plein. De même, un canal mis en mémoire tampon peut effectuer des opérations de lecture non bloquantes lorsque le tampon n'est pas vide, bloquant uniquement lorsque le tampon est vide.

En langage Go, transmettre des données via un canal est très simple. Par exemple, le code suivant montre comment créer 2 goroutines, une goroutine envoie des données au canal et l'autre goroutine reçoit des données du canal et les imprime :

package main

import "fmt"

func sender(ch chan int) {
    ch <- 10
    ch <- 20
    ch <- 30
    close(ch)
}

func receiver(ch chan int) {
    for {
        val, ok := <- ch
        if !ok {
            break
        }
        fmt.Println(val)
    }
}

func main() {
    ch := make(chan int)
    go sender(ch)
    go receiver(ch)
    fmt.Scanln()
}

Dans le code ci-dessus, nous créons un canal nommé ch , et transmettez-le à l'expéditeur et au destinataire deux goroutines. La goroutine de l'expéditeur envoie trois valeurs entières à ch, puis ferme le canal, indiquant que l'envoi des données est terminé. La goroutine du récepteur reçoit des valeurs entières de ch et imprime chaque valeur. À la fin, nous utilisons fmt.Scanln() pour bloquer la goroutine principale afin de garantir que le programme ne se termine pas.

Il est à noter que lorsqu'un canal est fermé, la goroutine qui en lit les données obtiendra immédiatement une valeur nulle sans blocage. Ainsi, dans le code ci-dessus, nous utilisons une boucle for pour lire en continu les données du canal, et la boucle se terminera lorsque le canal sera fermé.

En plus des chaînes ordinaires, le langage Go propose également des chaînes avec des déclarations sélectionnées. L'instruction select peut être utilisée pour sélectionner parmi plusieurs canaux. Une fois qu'un canal est prêt, l'opération correspondante sera effectuée immédiatement. Voici un exemple simple :

package main

import "fmt"

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)

    go func() {
        ch1 <- 10
    }()

    go func() {
        ch2 <- 20
    }()

    select {
    case val := <- ch1:
        fmt.Println("Received value from ch1:", val)
    case val := <- ch2:
        fmt.Println("Received value from ch2:", val)
    }
}

Dans le code ci-dessus, nous avons créé respectivement deux canaux ch1 et ch2 et leur avons envoyé des données. Dans la routine principale, nous utilisons l'instruction select pour sélectionner un canal préparé parmi deux canaux et imprimer la valeur reçue du canal. Dans cet exemple, puisque les données de ch1 arrivent en premier, select sélectionnera ch1 en premier.

En résumé, le canal en langage Go est une primitive de concurrence très importante qui peut être utilisée pour réaliser la communication et la synchronisation entre les goroutines. L'utilisation de canaux peut rendre la programmation simultanée simple et élégante, en particulier dans certains scénarios de concurrence complexes, le rôle des canaux est particulièrement évident.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!