Câu lệnh select là gì?

Question

Accepted Answer

**`select`** cho phép một goroutine chờ trên **nhiều thao tác channel** đồng thời, tiếp tục với bất cứ thao tác nào sẵn sàng trước. Nó giống một `switch` nhưng dành cho channel — thiết yếu để điều phối các thao tác concurrent, timeout, và hủy (cancellation).

## select cơ bản — chờ trên nhiều channel

```go
select {
case msg1 := <-ch1:
    fmt.Println("from ch1:", msg1)
case msg2 := <-ch2:
    fmt.Println("from ch2:", msg2)
case ch3 <- "hello":          // cũng có thể chờ để GỬI
    fmt.Println("sent to ch3")
}
// chặn cho đến khi MỘT case sẵn sàng, rồi chạy case đó
// nếu NHIỀU case sẵn sàng, một case được chọn NGẪU NHIÊN
```

`select` chặn cho đến khi một trong các thao tác channel của nó có thể tiếp tục, rồi thực thi case đó. Nếu nhiều case sẵn sàng cùng lúc, nó chọn ngẫu nhiên một (ngăn starvation).

## Timeout — một trường hợp sử dụng then chốt

```go
select {
case result := <-workCh:
    fmt.Println("got result:", result)
case <-time.After(2 * time.Second):     // kích hoạt sau 2 giây
    fmt.Println("timed out")             // đừng chờ mãi
}
```

Ghép một channel công việc với `time.After` là cách idiomatic để thêm một **timeout** — tiếp tục nếu kết quả đến, ngược lại bỏ cuộc sau một thời hạn. Điều này ngăn các goroutine bị chặn vô thời hạn.

## Thao tác không chặn với default

```go
select {
case msg := <-ch:
    fmt.Println("received:", msg)
default:
    fmt.Println("no message ready")     // chạy ngay nếu không có case nào sẵn sàng
}
// với một case default, select KHÔNG BAO GIỜ chặn — nó là một kiểm tra không chặn
```

Một case `default` khiến `select` không chặn: nếu không có channel nào sẵn sàng, `default` chạy ngay lập tức thay vì chờ.

## Hủy với context (rất phổ biến)

```go
func worker(ctx context.Context, jobs <-chan int) {
    for {
        select {
        case job := <-jobs:
            process(job)
        case <-ctx.Done():           // context bị hủy hoặc hết thời gian
            fmt.Println("shutting down:", ctx.Err())
            return                    // thoát sạch — ngăn rò rỉ goroutine
        }
    }
}
```

Pattern `case <-ctx.Done()` cho phép một goroutine lắng nghe tín hiệu hủy trong khi làm việc — cách chuẩn để khiến các goroutine có thể dừng được và tránh rò rỉ.

## Một pattern phổ biến: vòng lặp với select

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

## Tại sao điều này quan trọng

`select` là một công cụ nền tảng cho concurrency của Go — đó là cách các goroutine điều phối nhiều channel, cho phép các pattern thiết yếu cho các chương trình concurrent thực tế.

Các trường hợp sử dụng then chốt của nó rất quan trọng: **timeout** (`time.After`) ngăn việc chặn vô thời hạn; kiểm tra channel **không chặn** (`default`) tránh bị kẹt; và đặc biệt là **hủy** (`<-ctx.Done()`) cho phép các goroutine thoát sạch, vốn là phòng tuyến chính chống rò rỉ goroutine.

Không có `select`, bạn không thể chờ một cách thanh lịch trên nhiều channel, hiện thực các thời hạn, hoặc khiến các goroutine phản hồi với tín hiệu shutdown.

Hiểu `select` (hành vi chặn-cho-đến-khi-sẵn-sàng, lựa chọn ngẫu nhiên giữa các case sẵn sàng, `default` cho không chặn, và các idiom timeout/hủy) là thiết yếu để viết Go concurrent vững chắc, không rò rỉ và nằm trong số các chủ đề concurrency cốt lõi của ngôn ngữ.