Analyse des mécanismes de blocage et de non-blocage des canaux Golang

Analyse des mécanismes de blocage et de non-blocage des canaux Golang

Introduction :
Les canaux sont l'un des mécanismes de communication simultanés importants dans Golang, qui permettent la communication et la synchronisation entre les différentes Goroutines. Lors de l’utilisation des chaînes, nous rencontrons souvent des situations bloquantes et non bloquantes. Cet article présentera les mécanismes de blocage et de non-blocage des canaux et illustrera ses principes et son utilisation à travers des exemples de code.

1. Concepts de base du blocage et du non-blocage
   En programmation simultanée, le blocage et le non-blocage sont deux méthodes de traitement courantes. En termes simples, le blocage signifie que lorsqu'un Goroutine essaie de lire ou d'écrire un canal, si le canal n'est pas prêt, alors le Goroutine sera bloqué jusqu'à ce que le canal soit prêt. Le non-blocage signifie que le Goroutine n'est pas prêt, que le canal soit prêt ou non ; Le canal est prêt. Dans ce cas, l'exécution continue immédiatement.

Dans Golang, nous pouvons implémenter des mécanismes de blocage et de non-blocage des deux manières suivantes : en utilisant la longueur du canal et en utilisant l'instruction select. Ci-dessous, nous les présenterons un par un.

2. Utilisez la longueur du canal pour obtenir le blocage et le non-blocage
   Pour le canal sans tampon, sa longueur est de 0. Lorsqu'un Goroutine tente d'écrire des données sur un canal sans tampon, s'il n'y a aucun autre Goroutine en attente de lecture sur le même canal, l'opération d'écriture sera bloquée jusqu'à ce qu'un Goroutine soit prêt à lire les données. De même, lorsqu'un Goroutine tente de lire des données à partir d'un canal sans tampon, l'opération de lecture sera bloquée s'il n'y a aucun autre Goroutine en attente d'écriture sur le même canal.

Exemple de code :

package main

import "fmt"

func main() {
    ch := make(chan int) // 创建一个无缓冲 Channel

    go func() {
        fmt.Println("开始写入数据")
        ch <- 1 // 写入数据到 Channel
        fmt.Println("数据写入成功")
    }()

    fmt.Println("等待读取数据")
    data := <-ch // 从 Channel 读取数据
    fmt.Println("读取到数据：", data)
}

Dans le code ci-dessus, nous créons un canal ch sans tampon. Dans la fonction principale, nous démarrons une Goroutine qui écrit des données sur le canal ch. Dans le Goroutine principal, nous essayons de lire les données du canal ch, et comme il n'y a aucun autre Goroutine en attente d'écriture sur ce canal, l'opération de lecture est bloquée. L'opération de lecture ne continuera pas tant que le Goroutine qui a écrit les données n'aura pas fini de s'exécuter. ch。在 main 函数中，我们启动了一个 Goroutine，该 Goroutine 会向 Channel ch 写入数据。在主 Goroutine 中，我们试图从 Channel ch 中读取数据，由于没有其他 Goroutine 在此 Channel 上等待写入，读取操作会被阻塞。直到写入数据的 Goroutine 执行完成后，读取操作才会继续执行。

3. 利用 select 语句实现非阻塞
   除了利用 Channel 的长度实现阻塞和非阻塞之外，Golang 中还提供了 select 语句，使得我们可以更灵活地处理并发通信。

在 select 语句中，我们可以同时监听多个 Channel 的读取和写入操作。当一个或多个 Channel 准备好时，select 语句会随机选择一个可执行的操作进行执行。如果没有任何 Channel 准备好，那么 select 语句会进入阻塞状态，直到至少有一个 Channel 准备好。

代码示例：

package main

import "fmt"

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

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

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

    fmt.Println("开始监听 Channel")
    select {
    case data := <-ch1:
        fmt.Println("从 ch1 中读取到数据：", data)
    case data := <-ch2:
        fmt.Println("从 ch2 中读取到数据：", data)
    }
}

在上述代码中，我们创建了两个 Channel ch1 和 ch2

Utilisez l'instruction select pour obtenir le non-blocage

En plus d'utiliser la longueur du canal pour obtenir le blocage et le non-blocage, Golang fournit également des instructions select, nous permettant de gérer davantage les communications simultanées. avec souplesse.


Dans l'instruction select, nous pouvons surveiller les opérations de lecture et d'écriture de plusieurs canaux en même temps. Lorsqu'un ou plusieurs canaux sont prêts, l'instruction select sélectionne de manière aléatoire une opération exécutable à exécuter. Si aucun canal n'est prêt, l'instruction select entrera dans l'état de blocage jusqu'à ce qu'au moins un canal soit prêt.

Exemple de code :
• rrreee
Dans le code ci-dessus, nous avons créé deux canaux ch1 et ch2, et démarré deux Goroutines respectivement sur les deux canaux d'écriture de données. Dans le Goroutine principal, nous utilisons l'instruction select pour sélectionner une opération exécutable à partir de plusieurs canaux. Puisque les deux canaux sont prêts, l'instruction select sélectionnera au hasard l'une des opérations exécutables à exécuter.
• Conclusion : 

Grâce à l'introduction et aux exemples de code de cet article, nous avons découvert les mécanismes de blocage et de non-blocage des chaînes Golang. Dans le développement réel, nous devons choisir la méthode appropriée en fonction des différents besoins et scénarios. Qu'il s'agisse d'utiliser la longueur du canal ou l'instruction select, le mécanisme de communication simultanée de Golang peut fournir des capacités de traitement simultanées flexibles et efficaces. Lors de l'écriture de programmes simultanés, nous devons avoir une compréhension approfondie des mécanismes bloquants et non bloquants et choisir rationnellement les méthodes de traitement appropriées pour garantir l'exactitude et les performances du programme.

Références : 🎜🎜🎜https://gobyexample.com/channels🎜🎜https://go101.org/article/channel.html🎜🎜🎜(nombre de mots : 819 mots)🎜

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!