L'instruction Select

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 62 sur 107.

L'instruction select permet à une goroutine d'attendre simultanément sur plusieurs opérations de canal. C'est comme une instruction switch, mais chaque cas implique l'envoi ou la réception sur un canal. Lorsque plusieurs canaux sont prêts, select en choisit un au hasard.

func main() {
    ch1 := make(chan string)
    ch2 := make(chan string)
    
    go func() { ch1 <- "from channel 1" }()
    go func() { ch2 <- "from channel 2" }()
    
    select {
    case msg1 := <-ch1:
        fmt.Println(msg1)
    case msg2 := <-ch2:
        fmt.Println(msg2)
    }
}

Sans select, la réception depuis ch1 bloquerait jusqu'à ce que les données arrivent, risquant de manquer des données sur ch2. Avec select, le premier canal qui reçoit des données est traité.

Le cas default rend select non bloquant — il s'exécute immédiatement si aucun canal n'est prêt :

select {
case msg := <-messages:
    fmt.Println("Received:", msg)
default:
    fmt.Println("No message available")
}

Un modèle courant combine select avec des délais d'attente en utilisant time.After, qui renvoie un canal recevant une valeur après la durée spécifiée :

select {
case result := <-ch:
    fmt.Println("Got result:", result)
case <-time.After(2 * time.Second):
    fmt.Println("Timeout!")
}

Cela empêche votre programme d'attendre indéfiniment lorsqu'une opération sur un canal pourrait ne jamais se terminer.

Défi

Facile

Construisons un moniteur de service qui utilise l'instruction select pour gérer plusieurs sources de données simultanées. Votre moniteur écoutera différents canaux de service simultanément et répondra de manière appropriée lorsque des données arrivent ou lorsqu'aucune mise à jour n'est disponible.

Vous organiserez votre code sur deux fichiers :

monitor.go : Définissez votre logique de surveillance de service avec une gestion de canaux basée sur select.
Créez une structure ServiceUpdate avec les champs Name (string) et Status (string).

Implémentez une fonction Monitor qui prend trois canaux : primary chan ServiceUpdate, backup chan ServiceUpdate, et done chan bool. Cette fonction doit utiliser select pour écouter les trois canaux simultanément :
- Lors de la réception de primary : retourner la chaîne formatée Primary: [Name] is [Status]
- Lors de la réception de backup : retourner la chaîne formatée Backup: [Name] is [Status]
- Lors de la réception de done : retourner Monitoring stopped
Implémentez une fonction CheckStatus qui prend un seul canal updates chan ServiceUpdate et utilise select avec un cas default pour effectuer une vérification non bloquante :
- Si une mise à jour est disponible : retourner Update available: [Name]
- Si aucune mise à jour n'est disponible (cas par défaut) : retourner No updates pending
main.go : Configurez les canaux et démontrez les comportements select bloquants et non bloquants.
Lisez un mode à partir de l'entrée qui détermine le scénario à exécuter : primary, backup, stop, ou check.

Pour les modes primary, backup, et stop : lisez également un nom de service et un statut. Créez les trois canaux, lancez une goroutine qui envoie des données au canal approprié en fonction du mode, puis appelez Monitor et affichez son résultat.

Pour le mode check : lisez un nom de service et un statut, plus un indicateur (send ou nosend) indiquant s'il faut envoyer des données avant la vérification. Créez un canal tamponné avec une capacité de 1. Si l'indicateur est send, envoyez une mise à jour au canal avant d'appeler CheckStatus. Affichez le résultat de CheckStatus.

Les entrées suivantes seront fournies :

Ligne 1 : Mode (primary, backup, stop, ou check)
Ligne 2 : Nom du service
Ligne 3 : Statut du service
Ligne 4 (uniquement pour le mode check) : send ou nosend

Par exemple, étant donné :

primary
Database
healthy

Votre sortie devrait être :

Primary: Database is healthy

Et étant donné :

check
Cache
active
nosend

Votre sortie devrait être :

No updates pending

Aide-mémoire

L'instruction select permet à une goroutine d'attendre simultanément plusieurs opérations sur les canaux. Elle fonctionne comme une instruction switch, mais chaque cas implique l'envoi ou la réception d'un canal :

select {
case msg1 := <-ch1:
    fmt.Println(msg1)
case msg2 := <-ch2:
    fmt.Println(msg2)
}

Lorsque plusieurs canaux sont prêts, select en choisit un au hasard. Sans select, la réception d'un canal bloquerait et risquerait de manquer des données sur un autre canal.

Le cas default rend select non bloquant — il s'exécute immédiatement si aucun canal n'est prêt :

select {
case msg := <-messages:
    fmt.Println("Received:", msg)
default:
    fmt.Println("No message available")
}

Un modèle courant combine select avec des délais d'attente (timeouts) en utilisant time.After, qui renvoie un canal recevant une valeur après la durée spécifiée :

select {
case result := <-ch:
    fmt.Println("Got result:", result)
case <-time.After(2 * time.Second):
    fmt.Println("Timeout!")
}

Cela empêche votre programme d'attendre indéfiniment lorsqu'une opération sur un canal pourrait ne jamais se terminer.

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	var mode string
	fmt.Scanln(&mode)

	var serviceName string
	fmt.Scanln(&serviceName)

	var serviceStatus string
	fmt.Scanln(&serviceStatus)

	// TODO: Gérer les différents modes : "primary", "backup", "stop", "check"
	
	// Pour les modes "primary", "backup", "stop" :
	// - Créer trois canaux : primary, backup, done
	// - Lancer une goroutine qui envoie des données au canal approprié
	// - Appeler Monitor et afficher le résultat
	
	// Pour le mode "check" :
	// - Lire le drapeau supplémentaire ("send" ou "nosend")
	// - Créer un canal tamponné avec une capacité de 1
	// - Si le drapeau est "send", envoyer une mise à jour au canal
	// - Appeler CheckStatus et afficher le résultat
	
}