Comment utiliser la chaîne Golang

Le canal Golang est une fonctionnalité très importante du langage Go. En plus de gérer des tâches de programmation simultanées, il peut également être utilisé pour la transmission de messages et la notification d'événements. Dans les applications réelles, nous utilisons généralement des canaux pour améliorer la robustesse et l'évolutivité du programme. Cet article se concentrera sur l'utilisation de base du canal Golang.

1. Qu'est-ce que la chaîne Golang ?

Dans Golang, le canal est un type natif qui peut être utilisé pour transférer des données entre différentes goroutines. Un canal peut être vu comme un conteneur contenant un certain nombre d'éléments, chaque élément étant d'un type.

2. Définition et déclaration du canal Golang

Pour définir un canal, vous pouvez utiliser la méthode make pour spécifier la capacité et le type du canal :

ch := make(chan int, 10)

Le code ci-dessus crée un canal de type int d'une capacité de 10.

3. Opérations de base du canal Golang

1. Envoyer des données (transfert de données)

Nous pouvons utiliser l'opérateur de canal <- pour écrire des données vers et depuis le canal, comme indiqué ci-dessous : <- 来往channel写入数据，如下所示：

ch <- 100

上述代码就是将数据100写入channel ch 中。

2.接收数据（数据读取）

从channel中读取数据，也是使用channel的操作符 <- 进行操作。

data := <- ch

上述代码就是从 ch 中读取一个数据并赋给 data 变量。

3.关闭channel

在使用完一个channel后，我们需要将其关闭，用于告知receiver不会再收到任何数据。

close(ch)

四、Golang channel的阻塞特性

Golang中channel具有阻塞特性，这有助于我们管理程序资源、优化性能和提高可读性。

1.无缓冲channel的阻塞

在没有任何buffer的无缓冲channel中，接收方和发送方都会被阻塞。在下面示例中，无缓冲的channel ch 会阻塞 main 函数的执行，直到数据被发送和接受。

func main() {
    ch := make(chan int)
    go func() {
        fmt.Println("before data sent")
        ch <- 1
        fmt.Println("after data sent")
    }()
    fmt.Println("before data received")
    data := <-ch
    fmt.Println("data received:", data)
    fmt.Println("after data received")
}

在上述代码中，由于主goroutine先执行到读取channel，并且channel是阻塞的，所以它必须等待直到goroutine ch <- 1 中的数据被发送。

2.有缓冲channel的阻塞

相比无缓冲channel，在有缓冲channel中，sender将不会被阻塞直到有receiver接收到数据。根据缓冲区的大小，可以向channel中写入一定量的数据而不会阻塞。

在下面示例中，我们创建了一个缓存大小为2的有缓冲int类型channel，但是仅将一个数据发送给它：

func main() {
    ch := make(chan int, 2)
    fmt.Println("buffered channel created")
    ch <- 1
    fmt.Println("data sent")
}

由于channel的缓存大小为2，因此在向channel中写入第一条消息时，send操作没有被阻塞。但是，如果我们再尝试写入一条消息，它将会被阻塞，直到buffer中有空间。

3.select

select语句可用于处理多个channel并防止阻塞，它允许程序在多个channel之间进行选择，从而达到更好的并发处理和资源优化。对于任何一个case，可以接收或发送数据，select语句都是具有阻塞性的。

在下面的示例中，我们使用select来平衡对两个channel的读取：

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        time.Sleep(time.Second)
        ch1 <- 1
    }()
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- 2
    }()
    for i := 0; i < 2; i++ {
        select {
        case data1 := <-ch1:
            fmt.Println("data from ch1:", data1)
        case data2 := <-ch2:
            fmt.Println("data from ch2:", data2)
        }
    }
}

在上述例子中，select语法允许我们从服从通道ch1切换到ch2rrreee

Le code ci-dessus consiste à écrire les données 100 dans le canal ch.

2. Recevoir des données (lecture de données)

Lisez les données du canal et utilisez également l'opérateur de canal <- pour fonctionner. 🎜rrreee🎜Le code ci-dessus lit une donnée de ch et l'assigne à la variable data. 🎜🎜3. Fermez le canal🎜🎜Après avoir utilisé un canal, nous devons le fermer pour informer le récepteur qu'il ne recevra plus de données. 🎜rrreee🎜4. Les caractéristiques de blocage du canal Golang🎜🎜Le canal de Golang a des caractéristiques de blocage, ce qui nous aide à gérer les ressources du programme, à optimiser les performances et à améliorer la lisibilité. 🎜🎜1. Blocage des canaux sans tampon🎜🎜Dans un canal sans tampon sans aucun tampon, le récepteur et l'expéditeur seront bloqués. Dans l'exemple suivant, le canal sans tampon ch bloque l'exécution de la fonction main jusqu'à ce que les données soient envoyées et reçues. 🎜rrreee🎜Dans le code ci-dessus, puisque la goroutine principale s'exécute pour lire le canal en premier et que le canal est bloqué, il doit attendre que les données de la goroutine ch <- 1 soient envoyées. 🎜🎜2. Blocage des canaux tamponnés🎜🎜Par rapport aux canaux non tamponnés, dans les canaux tamponnés, l'expéditeur ne sera pas bloqué jusqu'à ce qu'un destinataire reçoive des données. Selon la taille du tampon, une certaine quantité de données peut être écrite sur le canal sans blocage. 🎜🎜Dans l'exemple suivant, nous créons un canal de type int tamponné avec une taille de cache de 2, mais nous lui envoyons une seule donnée : 🎜rrreee🎜Étant donné que la taille du cache du canal est de 2, les premières données sont écrites dans le canal lorsqu'un message est reçu, l'opération d'envoi n'est pas bloquée. Cependant, si nous essayons à nouveau d'écrire un message, il se bloquera jusqu'à ce qu'il y ait de l'espace dans le tampon. 🎜🎜3.select🎜🎜L'instruction select peut être utilisée pour traiter plusieurs canaux et empêcher le blocage. Elle permet au programme de choisir entre plusieurs canaux, obtenant ainsi un meilleur traitement simultané et une meilleure optimisation des ressources. Dans tous les cas, les données peuvent être reçues ou envoyées et l'instruction select est bloquante. 🎜🎜Dans l'exemple ci-dessous, nous utilisons select pour équilibrer les lectures sur les deux canaux : 🎜rrreee🎜Dans l'exemple ci-dessus, la syntaxe select nous permet d'obéir au canal ch1 Passez à ch2 jusqu'à ce que nous obtenions avec succès les données de l'un des canaux. Après cela, le programme se terminera. 🎜🎜Résumé : 🎜🎜Cet article présente en détail les chaînes en langage Go et explique l'utilisation spécifique et l'importance des chaînes Golang. Lorsque nous traitons de problèmes de programmation simultanée, le canal est souvent notre premier choix en matière de structure de données. Dans Golang, les canaux présentent de nombreux avantages, tels que la communication entre programmes, les mécanismes de synchronisation et de blocage, les sélecteurs, etc., qui peuvent permettre au langage Go d'être appliqué efficacement et de fonctionner efficacement dans de nombreux aspects. J'espère que cet article pourra vous aider à mieux utiliser les chaînes en langue Go et vous aider à développer des programmes en langue Go efficaces. 🎜

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!