Discussion approfondie sur l'utilisation d'instructions sélectionnées dans Golang

Dans Golang, l'instruction select est une structure de contrôle utile qui vous permet de choisir entre plusieurs canaux pour récupérer une valeur prête à être lue ou écrite sans bloquer d'autres opérations.

Dans cet article, nous approfondirons l'utilisation des instructions select dans Golang, sa syntaxe et son rôle dans la communication multicanal.

Bases de l'instruction Select

Dans Golang, nous utilisons des instructions select pour lire les données de plusieurs canaux. Ces canaux peuvent être de tout type comme des tuyaux, des canaux tamponnés, des canaux non tamponnés, etc. Voici un exemple de sélection simple :

package main

import "fmt"

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        for {
            c1 <- "from 1"
            time.Sleep(time.Second * 2)
        }
    }()

    go func() {
        for {
            c2 <- "from 2"
            time.Sleep(time.Second * 3)
        }
    }()

    go func() {
        for {
            select {
            case msg1 := <-c1:
                fmt.Println("Message 1", msg1)
            case msg2 := <-c2:
                fmt.Println("Message 2", msg2)
            }
        }
    }()

    var input string
    fmt.Scanln(&input)
}

Dans cet exemple, nous avons créé deux canaux c1 et c2. Ensuite, nous avons mis en place deux goroutines pour écrire des données sur le canal toutes les 2 secondes et 3 secondes respectivement. Nous utilisons une instruction select pour écouter toutes les chaînes et imprimer tous les messages reçus des chaînes.

La syntaxe de l'instruction select

Ce qui suit est la forme générale de l'instruction select :

select {
case <-channel1:
    // do something with channel1
case <-channel2:
    // do something with channel2
default:
    // do something default
}

L'instruction select comprend plusieurs instructions case et une instruction par défaut. Les opérations de canal sont incluses dans chaque instruction case, et ces canaux peuvent être différents types de canaux. Lorsque l'instruction select s'exécute, elle attend la fin de l'une des opérations de canal. Si des opérations sur plusieurs canaux sont prêtes, select sélectionnera aléatoirement l'un des canaux, c'est-à-dire sélectionnera aléatoirement un canal à exécuter.

S'il n'y a pas de canal préparé ou d'instruction par défaut, l'instruction par défaut est exécutée. S'il n'y a pas d'instruction par défaut, l'instruction select sera bloquée.

Scénarios d'utilisation de l'instruction select

L'instruction select est très utile lorsqu'il s'agit de communication multicanal. Voici quelques scénarios d'utilisation courants :

Scénario 1 : Traitement de flux

Si vous traitez des données en streaming, vous devez utiliser des instructions select pour lire les données de plusieurs canaux. Voici un exemple simple :

package main

import "fmt"

func main() {

    even := make(chan int)
    odd := make(chan int)
    quit := make(chan int)

    go send(even, odd, quit)
    receive(even, odd, quit)
}

func send(even, odd, quit chan<- int) {
    for i := 0; i <= 10; i++ {
        if i%2 == 0 {
            even <- i
        } else {
            odd <- i
        }
    }
    quit <- 0
}

func receive(even, odd, quit <-chan int) {
    for {
        select {
        case v := <-even:
            fmt.Println("Even number: ", v)
        case v := <-odd:
            fmt.Println("Odd number: ", v)
        case <-quit:
            return
        }
    }
}

Dans cet exemple, nous créons trois canaux : un canal pair, un canal impair et un canal de sortie. Dans la fonction d'envoi, nous envoyons une série de nombres. Dans la fonction de réception, nous utilisons des instructions select pour lire les nombres des canaux pairs et impairs et quitter lorsque le canal de sortie est prêt.

Scénario 2 : Gestion du délai d'attente

Dans certains cas, si l'opération prend beaucoup de temps, vous devrez peut-être ajouter une condition de délai d'attente à l'instruction select. Voici un exemple simple :

package main

import (
    "fmt"
    "time"
)

func main() {

    c1 := make(chan string)

    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()

    select {
    case result := <-c1:
        fmt.Println(result)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }
}

Dans cet exemple, nous créons un canal c1 et implémentons une opération avec un délai de 2 secondes dans une goroutine pour simuler une opération de longue durée. Ensuite, nous essayons de lire le résultat après avoir attendu le temps requis dans l'instruction select. Étant donné que le délai d'expiration est plus court que le temps d'opération, l'opération de lecture expirera et imprimera un message de délai d'attente au lieu de la valeur dans le canal.

Remarques sur les instructions select

Lors de l'utilisation des instructions select, vous devez faire attention aux points suivants :

1. Les instructions select ne peuvent être utilisées que pour les opérations de canal. Si vous devez effectuer une autre opération, vous ne pouvez pas utiliser l'instruction select.
2. L'instruction case dans l'instruction select doit être une opération non bloquante. Si votre instruction case contient une opération de blocage, elle ne sera jamais sélectionnée.
3. S'il y a une ambiguïté dans l'instruction case dans l'instruction select (par exemple, deux chaînes sont prêtes en même temps), une chaîne sera sélectionnée au hasard.
4. Si tous les cas de la sélection sont des opérations non bloquantes et qu'il n'y a pas d'instruction par défaut, l'instruction select se bloquera jusqu'à ce qu'au moins un canal soit prêt.

Conclusion

Dans cet article, nous avons une compréhension approfondie de l'utilisation, de la syntaxe et des scénarios d'utilisation de l'instruction select. Nous pouvons récupérer les données requises à partir de plusieurs canaux, permettant une communication et un contrôle de concurrence plus efficaces. En tant que développeur Golang, vous devez maîtriser l'instruction select afin de pouvoir l'utiliser de manière flexible dans la pratique.

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!