Hvad er select-sætningen?

Question

IT Interview Practice · Accepted Answer

**`select`** lader en goroutine vente på **multiple channel-operationer** samtidigt og fortsætter med det, som er klar først. Det er som en `switch` men for channels — essentielt for at koordinere concurrent-operationer, timeouts og cancellation.

## Basis select — vent på multiple channels

```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` blokerer, indtil en af dets channel-operationer kan fortsætte, og udfører derefter det case. Hvis flere er klar på én gang, vælger den en tilfældigt (for at forhindre starvation).

## Timeouts — et vigtig use case

```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
}
```

At kombinere en work channel med `time.After` er den idiomatiske måde at tilføje et **timeout** på — fortsæt, hvis resultatet ankommer, ellers give op efter en deadline. Dette forhindrer goroutines i at blive blokeret uendeligt.

## Ikke-blokerende operationer med 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
```

Et `default` case gør `select` ikke-blokerende: hvis ingen channel er klar, kører `default` umiddelbart i stedet for at vente.

## Cancellation med context (meget almindeligt)

```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
        }
    }
}
```

Mønsteret `case <-ctx.Done()` lader en goroutine lytte efter cancellation mens arbejde udføres — standardmåden at gøre goroutines stoppable og undgå leaks.

## Et almindeligt mønster: loop med select

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

## Hvorfor det betyder noget

`select` er et fundamentalt værktøj for Go concurrency — det er sådan goroutines koordinerer multiple channels, hvilket muliggør mønstre, der er essentielle for reelle concurrent-programmer.

Dets vigtigste brugsmåder er kritiske: **timeouts** (`time.After`) forhindrer uendelig blokering; **ikke-blokerende** channel-kontroller (`default`) forhindrer at blive stukket fast; og især **cancellation** (`<-ctx.Done()`) lader goroutines afslutte rent, hvilket er den primære forsvar mod goroutine-leaks.

Uden `select` kunne du ikke elegant vente på flere channels, implementere deadlines eller gøre goroutines responsive over for shutdown-signaler.

At forstå `select` (dens blokerings-til-klar-adfærd, tilfældig valg blandt klar cases, `default` for ikke-blokering, og timeout/cancellation-idiomerne) er essentielt for at skrive robust, leak-fri concurrent Go og er blandt kerneconcurrency-emnerne i sproget.

Basis select — vent på multiple channels

Timeouts — et vigtig use case

Ikke-blokerende operationer med default

Cancellation med context (meget almindeligt)

Et almindeligt mønster: loop med select

Hvorfor det betyder noget

Relaterede spørgsmål