Comment puis-je prioriser la gestion des canaux dans l'instruction « select » de Go ?

Gestion des priorités dans l'instruction select de Go

Dans Go, l'instruction select permet de surveiller plusieurs canaux simultanément. Cependant, il ne donne pas automatiquement la priorité à un canal par rapport à un autre lorsque les deux reçoivent des données. Cela peut être problématique si vous souhaitez vous assurer que certains messages sont traités dans un ordre spécifique.

Répondre aux problèmes prioritaires

Pour résoudre ce problème, nous pouvons tirer parti du mécanisme de fermeture de canal intégré de Go et itération de plage sur les canaux. Lorsqu'un canal est fermé, cela signale qu'aucune donnée ne sera transmise. En fermant le canal destiné à la sortie uniquement lorsque tous les messages souhaités ont été traités, nous pouvons effectivement créer un système de priorités.

Exemple de mise en œuvre

Considérons l'exemple suivant :

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

var (
    produced  = 0
    processed = 0
    m         sync.Mutex
)

func produceEndlessly(out chan int, quit chan bool) {
    defer close(out)
    for {
        out <- rand.Int()
        time.Sleep(time.Duration(rand.Int63n(5e6)))

        m.Lock()
        produced++
        m.Unlock()
    }
}

func quitRandomly(quit chan bool) {
    d := time.Duration(rand.Int63n(5e9))
    time.Sleep(d)

    m.Lock()
    if produced > 10 {
        close(quit)
    }
    m.Unlock()
}

func main() {
    vals, quit := make(chan int, 10), make(chan bool)
    go produceEndlessly(vals, quit)
    go quitRandomly(quit)
    for x := range vals {
        fmt.Println(x)

        m.Lock()
        processed++
        m.Unlock()
    }

    fmt.Println("Produced:", produced)
    fmt.Println("Processed:", processed)
}

Dans cet exemple :

• vals représente le canal recevant les messages.
• quit est le canal dédié pour signaler quand arrêter le traitement des messages.
• quitRandomly() ferme la sortie après un délai aléatoire, simulant un signal externe pour arrêter le traitement.
• produceEndlessly() génère un flux sans fin de messages sur vals.
• Maintient l'état partagé (produit et traité) à l'aide de mutex pour le thread sécurité.

En fermant quit lorsque la production dépasse 10, nous garantissons que les 10 messages sont traités avant la fin du programme. Itération de plage sur les blocs vals jusqu'à ce que le canal soit fermé, garantissant que tous les messages sont traités avant de quitter la boucle.

Cette approche fournit un moyen simple et efficace de prioriser le traitement des messages dans l'instruction select de Go.

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!