Apa iku statement select?

Question

Accepted Answer

**`select`** ngidini goroutine nunggu **operasi channel multiple** bebarengan, terus karo sing wis siap nang dhisik. Kaya `switch` nanging kanggo channel — penting kanggo koordinasi operasi concurrent, timeouts, lan pembatalan.

## Select dhasar — nunggu ing channel multiple

```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` nyegat nganti ana operasi channel sing bisa lanjut, banjur njalanin case kono. Yen pirang-pirang siap barengan, pilih siji sacara acak (nyegah nggotok).

## Timeouts — kasus nggunakake sing penting

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

Madhani channel karya karo `time.After` iku cara idiomatik nambah **timeout** — lanjut yen asil teka, yen ora sumurup sawisé deadline. Iki nyegah goroutine saka nyegat tanpa bates.

## Operasi non-blokir karo 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
```

Kasus `default` nggawe `select` non-blokir: yen channel ora ana sing siap, `default` nlayang langsung tinimbang nunggu.

## Pembatalan karo context (satusan umum)

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

Pola `case <-ctx.Done()` ngidini goroutine krungu pembatalan nalika gawe — cara standar nggawe goroutine bisa dipethik lan nyegah kebocoran.

## Pola umum: loop karo select

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

## Napa dadi penting

`select` iku alat dhasar kanggo concurrency Go — cara goroutine koordinasi channel multiple, ngidini pola sing penting kanggo program concurrent nyata.

Kagungan kunci kritis: **timeouts** (`time.After`) nyegah nyegat tanpa bates; **non-blokir** channel checks (`default`) nyegah macet; utamane **pembatalan** (`<-ctx.Done()`) ngidini goroutine metu becik, iku pertahanan utama nglawan kebocoran goroutine.

Tanpa `select`, ora bisa nunggu elegan ing pirang-pirang channel, nerapke deadline, utawa nggawe goroutine tanggap sinyal mateni.

Ngerti `select` (solah blokir-nganti-siap, pilihan acak ing antara case siap, `default` kanggo non-blokir, lan idiom timeout/pembatalan) penting kanggo nulis concurrent Go kuat, tanpa kebocoran, lan ing antarane topik concurrency inti ing basa.