Apakah pernyataan select?

Question

Accepted Answer

**`select`** memungkinkan goroutine menunggu **operasi saluran berganda** secara serentak, melanjutkan dengan yang siap paling awal. Ini seperti `switch` tetapi untuk saluran — penting untuk mengoordinasikan operasi bersamaan, batas waktu, dan pembatalan.

## Pilih dasar — tunggu pada saluran berganda

```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` memblokir hingga salah satu operasi salurannya dapat dilanjutkan, kemudian menjalankan kasus itu. Jika beberapa siap sekaligus, ia memilih satu secara acak (mencegah kelaparan).

## Batas waktu — kasus penggunaan utama

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

Memasangkan saluran kerja dengan `time.After` adalah cara idiomatis untuk menambahkan **batas waktu** — lanjutkan jika hasilnya tiba, jika tidak berhenti setelah tenggat. Ini mencegah goroutine memblokir tanpa batas.

## Operasi non-pemblokiran dengan 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` membuat `select` tidak memblokir: jika tidak ada saluran yang siap, `default` berjalan segera alih-alih menunggu.

## Pembatalan dengan konteks (sangat 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()` memungkinkan goroutine mendengarkan pembatalan sambil bekerja — cara standar membuat goroutine dapat dihentikan dan menghindari kebocoran.

## Pola umum: loop dengan select

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

## Mengapa itu penting

`select` adalah alat fundamental untuk keselarasan Go — ini adalah cara goroutine mengoordinasikan saluran berganda, memungkinkan pola yang penting untuk program bersamaan nyata.

Penggunaan utamanya sangat krusial: **batas waktu** (`time.After`) mencegah pemblokiran tanpa batas; pemeriksaan saluran **non-pemblokiran** (`default`) menghindari terjebak; dan terutama **pembatalan** (`<-ctx.Done()`) memungkinkan goroutine keluar dengan bersih, yang merupakan pertahanan utama terhadap kebocoran goroutine.

Tanpa `select`, Anda tidak dapat dengan elegan menunggu beberapa saluran, menerapkan tenggat waktu, atau membuat goroutine responsif terhadap sinyal penghentian.

Memahami `select` (perilaku pemblokiran-hingga-siap, pilihan acak di antara kasus yang siap, `default` untuk non-pemblokiran, dan idiom batas waktu/pembatalan) penting untuk menulis Go bersamaan yang kuat, bebas kebocoran, dan termasuk di antara topik keselarasan inti dalam bahasa.