utilisation du canal Golang

Golang est un langage de programmation moderne qui convient principalement au cloud computing et aux applications basées sur le Big Data. Le langage possède des fonctionnalités telles que l’efficacité, la fiabilité et la sécurité. L’une des fonctionnalités les plus uniques est le canal.

Les canaux sont un type très puissant dans le langage Golang qui permettent de partager des données en toute sécurité entre différents programmes simultanés. Cet article approfondira l'utilisation des canaux et montrera comment utiliser les canaux dans les programmes pour réaliser le co-traitement et la synchronisation.

Concepts de base

Dans Golang, un canal est un objet utilisé pour transférer des données entre coroutines. Grâce aux canaux, Golang garantit que les données sont thread-safe lors de leur lecture ou de leur écriture. Les canaux peuvent être déclarés des manières suivantes :

var ch chan int           //声明一个通道变量
ch := make(chan int)      //定义通道，并初始化其容量

Il existe principalement 3 types de canaux :

1. Canal unidirectionnel : prend uniquement en charge l'envoi ou la réception de données

2. réception de données

3. Canal de cache : Type de canal à capacité fixe

Utilisation des canaux

Les canaux sont créés à l'aide de la fonction make. La création d'un canal nécessite de spécifier le type et la capacité du canal (s'il s'agit d'un canal mis en mémoire tampon). Par exemple, pour créer un canal en cache d'une capacité de 3, vous pouvez utiliser le code suivant :

ch := make(chan int, 3)

Un canal a deux opérations principales :

1 Opération d'envoi : Les données peuvent être envoyées à une autre coroutine via le canal

. 2. Opération de réception : la coroutine peut recevoir des données du canal.

Dans Golang, le type de données du canal a la même valeur par défaut que les autres variables. Pour les voies, cette valeur est « nulle ». Par conséquent, avant d'utiliser un canal, il doit être initialisé à l'aide de la fonction make. Si le canal n'est pas initialisé, une exception d'exécution « panique » est levée.

Dans la programmation réelle, les chaînes peuvent être utilisées dans de nombreux scénarios et cas d'utilisation différents. Voici quelques exemples largement utilisés :

1. Mode bloquant/non bloquant des chaînes : dans Golang, les chaînes peuvent fonctionner en modes bloquant et non bloquant. En mode blocage, les opérations de réception et d'envoi du canal attendent que l'envoi ou la réception soit terminé. En mode non bloquant, ils reviennent immédiatement si l'opération ne peut pas être complétée.

Utiliser des canaux pour bloquer la communication dans Go :

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func() {
        ch <- 101         //发送数据到通道
    }()
    ret := <- ch          //从通道读取数据
    fmt.Println(ret)
}

Dans cet exemple, deux coroutines communiquent en envoyant et en recevant des données sur un canal. Une fois le canal créé, passez-le en paramètre à la fonction "go", qui représente la fonction qui sera exécutée dans la goroutine.

2. Opérations synchrones et asynchrones des coroutines : les canaux peuvent également être utilisés pour des opérations synchrones et asynchrones entre les coroutines. Dans Golang, l'utilisation de canaux pour transférer des données entre coroutines peut réaliser des opérations synchrones et asynchrones de coroutines.

L'exemple de code pour le fonctionnement synchrone est le suivant :

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string)
    go func() {
        time.Sleep(time.Second * 2)
        ch <- "golang"
    }()
    fmt.Println("Waiting for the channel...")
    data := <- ch
    fmt.Println("Got data:", data)
}

Dans cet exemple, une donnée sera envoyée de la coroutine au canal après 2 secondes. Le processus principal attendra que le canal termine l'opération d'envoi ou de réception avant d'exécuter le code suivant.

Un exemple de code pour une opération asynchrone est le suivant :

package main 

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 1)
    go func() {
        for i := 0; i < 5; i++ {
            ch <- i
            fmt.Printf("goroutine #%d puts %d at %v
",i,i, time.Now().Unix())
        }
    }()
    time.Sleep(time.Second * 2)
    for i := 0; i < 5; i++ {
        v := <- ch
        fmt.Printf("main thread gets %d at %v
",v, time.Now().Unix())
    }
}

Ce code générera un canal mis en cache et le transmettra en tant que paramètre à une fonction entre les coroutines. Cette fonction écrit des entiers sur le canal, de 0 à 4.

Dans le processus principal, le code attend 2 secondes pour basculer, puis lit les données du canal dans la boucle. Le résultat montre que les données du canal auquel accède le thread principal et les horodatages de l'exécution inter-coroutines sont dans l'ordre inverse.

3. Mode d'itération du canal : Le canal peut être itéré pour accéder à toutes les valeurs du canal.

package main

import "fmt"

func main() {
    ch := make(chan int,4)
    ch <- 34
    ch <- 18
    ch <- 89
    ch <- 56
    close(ch)
    for x := range ch {
        fmt.Println(x)
    }
}

En mode itération, parcourez les valeurs du canal par plage et quittez automatiquement le parcours lorsque le canal est fermé.

Résumé

Cet article présente l'utilisation de base des canaux Golang et montre comment utiliser les canaux pour réaliser des opérations collaboratives, synchrones et asynchrones entre les coroutines. Grâce à la compréhension et à la familiarité avec les canaux, des programmes simultanés efficaces, sûrs et fiables peuvent être mieux mis en œuvre.

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!