คำสั่ง select คืออะไร?

Question

Accepted Answer

**`select`** ช่วยให้ goroutine รอการดำเนินการบน **channel หลายตัว** ได้พร้อมกัน โดยจะดำเนินการต่อกับตัวใดก็ตามที่พร้อมก่อน มันเหมือน `switch` แต่สำหรับ channel — จำเป็นสำหรับการประสานงานการดำเนินการที่ทำพร้อมกัน การ timeout และการยกเลิก (cancellation)

## select พื้นฐาน — รอบน channel หลายตัว

```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` จะ block จนกว่าการดำเนินการบน channel ตัวใดตัวหนึ่งจะดำเนินต่อได้ แล้วจึงรัน case นั้น หากหลาย case พร้อมพร้อมกัน มันจะเลือกแบบสุ่ม (ป้องกัน starvation)

## timeout — กรณีการใช้งานสำคัญ

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

การจับคู่ channel ของงานกับ `time.After` เป็นวิธีที่เป็นสำนวนในการเพิ่ม **timeout** — ดำเนินต่อหากผลลัพธ์มาถึง มิฉะนั้นจะเลิกหลังจากครบกำหนดเวลา สิ่งนี้ป้องกันไม่ให้ goroutine ถูก block อย่างไม่มีกำหนด

## การดำเนินการแบบไม่ block ด้วย 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
```

case `default` ทำให้ `select` ไม่ block: หากไม่มี channel ใดพร้อม `default` จะรันทันทีแทนการรอ

## การยกเลิกด้วย context (พบบ่อยมาก)

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

รูปแบบ `case <-ctx.Done()` ช่วยให้ goroutine คอยฟังการยกเลิกขณะทำงาน — เป็นวิธีมาตรฐานในการทำให้ goroutine หยุดได้และหลีกเลี่ยงการรั่วไหล

## รูปแบบที่พบบ่อย: loop ร่วมกับ select

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

## ทำไมจึงสำคัญ

`select` เป็นเครื่องมือพื้นฐานสำหรับ concurrency ใน Go — มันคือวิธีที่ goroutine ประสานงาน channel หลายตัว เปิดทางรูปแบบที่จำเป็นสำหรับโปรแกรม concurrent จริง ๆ

การใช้งานหลักของมันสำคัญยิ่ง: **timeout** (`time.After`) ป้องกันการ block อย่างไม่มีกำหนด; การตรวจสอบ channel แบบ **ไม่ block** (`default`) หลีกเลี่ยงการติดค้าง; และโดยเฉพาะอย่างยิ่ง **การยกเลิก** (`<-ctx.Done()`) ช่วยให้ goroutine ออกได้อย่างสะอาด ซึ่งเป็นการป้องกันหลักต่อ goroutine leak

หากไม่มี `select` คุณจะไม่สามารถรอบน channel หลายตัวอย่างสง่างาม, ทำ deadline หรือทำให้ goroutine ตอบสนองต่อสัญญาณ shutdown ได้

การเข้าใจ `select` (พฤติกรรม block-จนกว่าจะพร้อม, การเลือกแบบสุ่มในบรรดา case ที่พร้อม, `default` สำหรับการไม่ block และสำนวน timeout/cancellation) เป็นสิ่งจำเป็นสำหรับการเขียน Go แบบ concurrent ที่แข็งแกร่งและไม่รั่วไหล และเป็นหนึ่งในหัวข้อ concurrency หลักในภาษานี้