Qu'est-ce que la déclaration select ?

Question

IT Interview Practice · Accepted Answer

**`select`** permet à une goroutine d'attendre **plusieurs opérations sur canaux** simultanément, en procédant avec celle qui est prête en premier. C'est comme un `switch` mais pour les canaux — essentiel pour coordonner les opérations concurrentes, les délais d'attente et l'annulation.

## Select basique — attendre plusieurs canaux

```go
select {
case msg1 := <-ch1:
    fmt.Println("from ch1:", msg1)
case msg2 := <-ch2:
    fmt.Println("from ch2:", msg2)
case ch3 <- "hello":          // can also wait to SEND
    fmt.Println("sent to ch3")
}
// blocks until ONE case is ready, then runs that case
// if MULTIPLE are ready, one is chosen at RANDOM
```

`select` se bloque jusqu'à ce que l'une de ses opérations sur canal puisse procéder, puis exécute ce cas. Si plusieurs sont prêtes à la fois, il en choisit une aléatoirement (prévenant la famine).

## Délais d'attente — un cas d'usage clé

```go
select {
case result := <-workCh:
    fmt.Println("got result:", result)
case <-time.After(2 * time.Second):     // fires after 2 seconds
    fmt.Println("timed out")             // don't wait forever
}
```

Associer un canal de travail avec `time.After` est la manière idiomatique d'ajouter un **délai d'attente** — procéder si le résultat arrive, sinon abandonner après une limite. Cela empêche les goroutines de se bloquer indéfiniment.

## Opérations non-bloquantes avec default

```go
select {
case msg := <-ch:
    fmt.Println("received:", msg)
default:
    fmt.Println("no message ready")     // runs immediately if no case is ready
}
// with a default case, select NEVER blocks — it's a non-blocking check
```

Un cas `default` rend `select` non-bloquant : si aucun canal n'est prêt, `default` s'exécute immédiatement au lieu d'attendre.

## Annulation avec context (très courant)

```go
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():           // context cancelled or timed out
            fmt.Println("shutting down:", ctx.Err())
            return                    // clean exit — prevents goroutine leak
        }
    }
}
```

Le motif `case <-ctx.Done()` permet à une goroutine d'écouter une annulation tout en effectuant un travail — la manière standard de rendre les goroutines arrêtables et d'éviter les fuites.

## Un motif courant : boucle avec select

```go
for {
    select {
    case data := <-dataCh:  ...
    case <-quit:            return
    }
}
```

## Pourquoi c'est important

`select` est un outil fondamental pour la concurrence en Go — c'est comment les goroutines coordonnent plusieurs canaux, activant des motifs essentiels pour les vrais programmes concurrents.

Ses usages clés sont critiques : les **délais d'attente** (`time.After`) préviennent les blocages indéfinis ; les **vérifications non-bloquantes** de canaux (`default`) évitent de rester bloqué ; et surtout l'**annulation** (`<-ctx.Done()`) permet aux goroutines de quitter proprement, ce qui est la défense principale contre les fuites de goroutines.

Sans `select`, vous ne pourriez pas attendre élégamment plusieurs canaux, implémenter des délais, ou rendre les goroutines réactives aux signaux d'arrêt.

Comprendre `select` (son comportement de blocage jusqu'à prêt, le choix aléatoire parmi les cas prêts, le `default` pour non-bloquant, et les idiomes de délai d'attente/annulation) est essentiel pour écrire du Go concurrent robuste et sans fuites, et fait partie des sujets de concurrence essentiels du langage.

Select basique — attendre plusieurs canaux

Délais d'attente — un cas d'usage clé

Opérations non-bloquantes avec default

Annulation avec context (très courant)

Un motif courant : boucle avec select

Pourquoi c'est important

Questions connexes