Méthode de traitement asynchrone de la programmation simultanée Select Channels Go à l'aide de Golang

Sélectionnez les canaux à l'aide de la méthode de traitement asynchrone golang de la programmation simultanée Go

Introduction :
La programmation simultanée est un domaine important dans le développement de logiciels modernes, qui peut améliorer efficacement les performances et la réactivité des applications. Dans le langage Go, la programmation simultanée peut être implémentée de manière simple et efficace à l'aide des instructions Channels et Select. Cet article explique comment utiliser Golang pour effectuer un traitement asynchrone de la programmation simultanée Select Channels Go et fournit des exemples de code spécifiques.

1. Comprendre les canaux et les instructions Select
Les canaux sont des canaux de communication entre les goroutines. L'utilisation de canaux peut réaliser le transfert de données entre différentes goroutines. Dans Golang, un canal peut être créé en utilisant le mot-clé make, comme indiqué dans le code suivant :

ch := make(chan int)

Utilisez ch <- value pour envoyer des données au canal, <- ch pour recevoir des données du canal. De cette façon, nous pouvons échanger des données dans différentes goroutines. L'instruction Select est utilisée pour surveiller les opérations de plusieurs canaux en même temps. Lorsque l'un des canaux est prêt, l'instruction Select effectuera l'opération correspondante.

2. Utilisez l'instruction Select pour le traitement asynchrone
En programmation simultanée, il est souvent nécessaire de traiter plusieurs tâches différentes en même temps au lieu de les traiter une par une dans l'ordre. À ce stade, vous pouvez utiliser l'instruction Select pour implémenter le traitement asynchrone, comme indiqué dans le code suivant :

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
    }()

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

Dans le code ci-dessus, nous avons créé deux canaux ch1 et ch2 et leur avons envoyé des données respectivement dans deux goroutines. Utilisez l'instruction Select pour écouter ces deux canaux et effectuez l'opération correspondante lorsque l'un des canaux est prêt. Dans le code, ch1 envoie d'abord les données au canal. Après une seconde, ch1 est prêt. L'instruction Select effectue l'opération correspondante et imprime « Reçu de ch1 » si les temps de veille de ch1 et ch2 sont échangés, ce sera le cas. imprimé en premier. "Reçu de ch2".

3. Caractéristiques de l'instruction Select

1. Si plusieurs canaux sont prêts, l'instruction Select en sélectionnera un au hasard pour l'exécution.
2. Utilisez la clause par défaut pour effectuer certaines opérations par défaut lorsque tous les canaux ne sont pas prêts.
3. Les instructions Select peuvent être imbriquées dans des boucles for pour réaliser plusieurs surveillances en définissant des conditions de sortie.

4. Utilisez l'instruction Select pour résoudre le problème de délai d'attente
Dans les applications pratiques, il est souvent nécessaire de définir un délai d'attente lorsqu'aucune donnée du canal n'est reçue dans le délai spécifié, le traitement correspondant est effectué. Cette fonction peut être obtenue en combinant un timer et une instruction Select, comme indiqué dans le code suivant :

func main() {
    ch := make(chan int)
    timeout := time.After(2 * time.Second)

    go func() {
        time.Sleep(3 * time.Second)
        ch <- 1
    }()

    select {
    case <-ch:
        fmt.Println("Received from ch")
    case <-timeout:
        fmt.Println("Timeout")
    }
}

Dans le code ci-dessus, nous créons un timeout timeout et utilisons l'instruction select pour écouter les événements ch et timeout. Dans la goroutine, les données sont envoyées à ch après 3 secondes de simulation via la fonction Sleep, et le délai d'attente est réglé sur 2 secondes. Par conséquent, après 2 secondes, le délai d'attente sera prêt et l'instruction select effectuera le traitement du délai d'attente et imprimera "Timeout".

Conclusion : 
Grâce aux instructions Channels et Select, nous pouvons effectuer un traitement asynchrone et une programmation simultanée de manière simple et efficace. En utilisant rationnellement les instructions goroutine, Channel et Select, les performances et la réactivité du programme peuvent être améliorées. J'espère que cet article sera utile pour comprendre la méthode de traitement asynchrone de l'utilisation de la programmation simultanée Select Channels Go dans Golang.

Références :
https://golang.org/doc/effective_go.html#concurrency
https://go.dev/play/p/t4VZEnhoyC4

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!