Concurrency pattern ที่พบบ่อยใน Go มีอะไรบ้าง?

Question

Accepted Answer

goroutine และ channel ของ Go ช่วยให้เกิดชุดของ **concurrency pattern** ที่เป็นที่ยอมรับกันดี ซึ่งแก้ปัญหาที่พบบ่อย เช่น การกระจายงาน, การ fan-out/in, pipeline และ rate limiting การรู้จัก pattern ที่เป็น idiomatic เหล่านี้ช่วยให้คุณสร้างระบบ concurrent ที่ถูกต้องและมีประสิทธิภาพได้

## Worker pool — จำกัดขอบเขต concurrency

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // a FIXED number of workers
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // each worker pulls jobs until the channel closes
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

**Worker pool** จะรัน goroutine จำนวนคงที่ที่ดึงงานจาก jobs channel ที่ใช้ร่วมกัน ซึ่งเป็นการจำกัดขอบเขต concurrency (เช่น อย่าเปิด DB connection 10,000 ตัว แต่ใช้ worker 10 ตัวแทน) นี่คือ pattern ที่สำคัญที่สุดสำหรับการควบคุมการใช้ทรัพยากร

## Fan-out / fan-in

```text
Fan-out: distribute work across MULTIPLE goroutines (parallelize)
Fan-in:  MERGE results from multiple goroutines back into one channel
```

```go
// fan-in: merge several channels into one
func merge(channels ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    for _, ch := range channels {
        wg.Add(1)
        go func(c <-chan int) {
            defer wg.Done()
            for v := range c { out <- v }   // forward each channel's values to out
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // close out when all sources are drained
    return out
}
```

## Pipeline — stage ที่เชื่อมต่อกันด้วย channel

```go
// each stage is a goroutine: receives from an input channel, sends to an output channel
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() { for _, n := range nums { out <- n }; close(out) }()
    return out
}
func square(in <-chan int) <-chan int {
    out := make(chan int)
    go func() { for n := range in { out <- n * n }; close(out) }()
    return out
}
// compose: square(generate(1,2,3)) → a streaming pipeline
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

**Pipeline** จะเชื่อม stage ของการประมวลผลเข้าด้วยกันผ่าน channel ข้อมูลจะไหลผ่านเป็น stream โดยแต่ละ stage แปลงข้อมูลแบบ concurrent

## Rate limiting

```go
limiter := time.Tick(200 * time.Millisecond)   // a tick every 200ms
for req := range requests {
    <-limiter                                    // wait for the next tick before proceeding
    go handle(req)                                // → at most 5 requests/second
}
```

## Cancellation ด้วย context (cross-cutting)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // stop on cancellation — prevents leaks
}
```

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

concurrency pattern เหล่านี้คือชุดเครื่องมือเชิงปฏิบัติสำหรับการสร้างระบบ Go ที่ concurrent จริง ๆ โดยเปลี่ยน goroutine และ channel ดิบ ๆ ให้เป็นโซลูชันที่มีโครงสร้างและถูกต้องสำหรับปัญหาที่เกิดขึ้นซ้ำ ๆ

**Worker pool** มีความสำคัญเป็นพิเศษ เพราะมันจำกัดขอบเขต concurrency เพื่อปกป้องทรัพยากรที่มีจำกัด (database connection, API rate limit, หน่วยความจำ) ป้องกันความผิดพลาดที่พบบ่อยในการสร้าง goroutine แบบไม่จำกัดจนทำให้ระบบหมดทรัพยากร **Fan-out/fan-in** ทำงานแบบขนานและรวมผลลัพธ์ **pipeline** จำลองการแปลงข้อมูลแบบ streaming ได้อย่างเรียบร้อย **rate limiting** ควบคุม throughput

เมื่อรวมกับ **context-based cancellation** (เพื่อหลีกเลี่ยง goroutine leak) pattern เหล่านี้คือวิธีที่ Go service ระดับ production จัดการ concurrency ได้อย่างปลอดภัยและมีประสิทธิภาพ

การเข้าใจสิ่งเหล่านี้ โดยเฉพาะการรู้ว่าต้องจำกัดขอบเขต concurrency ด้วย worker pool แทนที่จะสร้าง goroutine แบบไม่จำกัด เป็นเครื่องหมายของความเชี่ยวชาญ Go ระดับ senior และเป็นหัวข้อสัมภาษณ์ขั้นสูงที่พบบ่อย เพราะ concurrency แบบ naive (goroutine ไม่จำกัด, leak, race) เป็นแหล่งของความล้มเหลวใน production ที่พบบ่อย