utilisation du canal Golang

Golang est un langage de programmation populaire en raison de son efficacité, de la sécurité de sa mémoire et de sa concurrence. Dans Golang, la communication simultanée peut être facilement réalisée à l'aide de canaux, ce qui est également l'un des principaux avantages de Golang. Cet article fournira une introduction approfondie aux concepts de base, à l'utilisation et à certaines techniques des canaux dans Golang.

1. Qu'est-ce que le canal

Dans Golang, le canal est une structure de données utilisée pour la communication Goroutine. Il peut être tamponné ou non. Un canal sans tampon est un canal synchrone qui bloque à la fois l'envoi et la réception de données. Lorsque les données envoyées ne sont pas reçues, l'opération d'envoi sera bloquée jusqu'à ce qu'un Goroutine reçoive les données. De même, lorsque le récepteur n'est pas prêt à recevoir des données, l'opération de réception sera bloquée. Un canal mis en mémoire tampon permet aux données d'être envoyées et reçues avant que le tampon ne soit plein, et la capacité du tampon est la taille spécifiée lors de la création du canal.

Le canal peut être défini et initialisé de la manière suivante :

var ch chan int // 定义一个 int 类型的 channel

ch = make(chan int) // 初始化 channel

ch := make(chan int) // 定义并初始化 channel

2. Utilisation du canal

Dans Golang, lors de l'utilisation du canal, cela implique généralement les deux opérations suivantes :

• Envoi de données
• Réception de données

Syntaxe de base pour l'envoi de données via le canal :

ch <- data  // 将 data 发送到 channel ch 上

Syntaxe de base pour la réception de données via le canal :

data := <- ch // 从 channel ch 中接收数据，并将其赋值给变量 data

Remarque : L'opération de réception se bloquera jusqu'à ce que les données soient envoyées au canal si le canal a été fermé et qu'il ne contient aucune donnée. , l'opération de réception sera effectuée immédiatement. Renvoie, attribuant une valeur nulle à la variable reçue.

Voici un exemple simple :

package main

import "fmt"

func main() {
    ch := make(chan int)
    go sendData(ch)

    for i := range ch {
        fmt.Println("Received:", i)
        if i == 10 {
            break
        }
    }
}

func sendData(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch) // 关闭 channel
}

Dans l'exemple ci-dessus, nous définissons une fonction sendDate pour envoyer des données à ch. Dans la fonction principale, nous créons un canal et utilisons la méthode range pour recevoir les données du canal une par une. Lorsque les données reçues sont 10, nous sortons de la boucle et fermons le canal.

3. Les caractéristiques de blocage du canal

Dans Golang, le canal est une structure de données bloquante, ce qui signifie que lorsque Goroutine essaie d'envoyer des données à un canal complet ou de recevoir des données d'un canal vide, ils seront bloqués. Cela permet de garantir la synchronisation et la collaboration entre les Goroutines.

Ensuite, nous démontrerons les caractéristiques de blocage du canal à travers un exemple :

package main

import "fmt"

func main() {
    ch := make(chan int, 2)

    ch <- 1 // 发送数据
    ch <- 2

    fmt.Println(<-ch) // 接收数据
    fmt.Println(<-ch)

    ch <- 3
    fmt.Println("数据已经被发送，但是没有接收方")
}

Dans cet exemple, nous créons un canal avec une taille de tampon de 2 et essayons de lui envoyer 3 données. Les deux premières données peuvent être envoyées car le tampon n'est pas encore plein. Mais lorsque nous essayons de recevoir ces données, nous devons attendre le destinataire de chaque donnée une par une avant de pouvoir continuer l'envoi. À la troisième tentative d'envoi de données au canal, l'expéditeur sera bloqué car il n'y a pas de récepteur.

4. Fermeture de la chaîne

Dans Golang, la chaîne peut être fermée via la méthode de fermeture. Un canal fermé renverra une valeur nulle une fois reçu et ne sera pas bloqué. Cela permet au récepteur de déterminer avec précision si le canal a été fermé après avoir reçu les données.

Voici un exemple :

package main

import "fmt"

func main() {
    ch := make(chan int)

    go sendData(ch)

    for i := range ch {
        fmt.Println("Received:", i)
    }
}

func sendData(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch) // 关闭 channel
}

Dans cet exemple, lorsque la fonction sendDate aura fini d'envoyer les données, elle utilisera la méthode close pour fermer le canal. Dans la fonction principale, nous utilisons la méthode range pour recevoir les données transmises depuis le canal ; lorsqu'il n'y a pas de données dans le canal, la méthode range quittera la boucle.

5. Sélecteur de chaîne

En plus des opérations de base des chaînes ci-dessus, Golang fournit également un sélecteur (sélectionner) qui peut choisir entre plusieurs chaînes. Ceci est utile pour gérer les opérations d’envoi et de réception sur plusieurs canaux.

Voici un exemple :

package main

import (
    "fmt"
    "time"
)

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

    go func() {
        time.Sleep(2 * time.Second)
        ch1 <- 1
    }()

    go func() {
        time.Sleep(5 * time.Second)
        ch2 <- 2
    }()

    for i := 0; i < 2; i++ {
        select {
        case <-ch1:
            fmt.Println("Received from ch1")
        case <-ch2:
            fmt.Println("Received from ch2")
        }
    }
}

Dans cet exemple, nous définissons deux canaux. Envoyez des données au canal après un délai de 2 secondes et 5 secondes dans les deux Goroutines respectivement. Ensuite, dans la fonction principale, nous utilisons la méthode select pour écouter les deux chaînes. Lorsqu'il y a des données dans le canal, la méthode de sélection répondra.

6. Résumé

Dans Golang, la chaîne est un outil très puissant et facile à utiliser. Grâce aux canaux, nous pouvons réaliser la communication et la synchronisation entre les Goroutines, améliorant ainsi les performances de simultanéité des programmes. Cet article présente les concepts de base, l'utilisation et certaines techniques des canaux, dans l'espoir d'aider les lecteurs à mieux comprendre comment utiliser les canaux pour créer des programmes concurrents fiables.

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!