Các pattern concurrency phổ biến trong Go là gì?

Question

Accepted Answer

Goroutine và channel của Go cho phép một tập các **pattern concurrency** được thiết lập tốt, giải quyết các vấn đề phổ biến — phân phối công việc, fan-out/fan-in, pipeline, và rate limiting. Biết các pattern idiomatic này cho phép bạn xây dựng các hệ thống concurrent đúng đắn, hiệu quả.

## Worker pool — concurrency có giới hạn

```go
func workerPool(jobs <-chan int, results chan<- int, numWorkers int) {
    var wg sync.WaitGroup
    for w := 0; w < numWorkers; w++ {     // một số CỐ ĐỊNH các worker
        wg.Add(1)
        go func() {
            defer wg.Done()
            for job := range jobs {        // mỗi worker lấy job cho đến khi channel đóng
                results <- process(job)
            }
        }()
    }
    wg.Wait()
    close(results)
}
```

Một **worker pool** chạy một số goroutine cố định tiêu thụ từ một channel job chung — giới hạn concurrency (ví dụ, đừng mở 10.000 kết nối DB; dùng 10 worker). Đây là pattern quan trọng nhất để kiểm soát việc sử dụng tài nguyên.

## Fan-out / fan-in

```text
Fan-out: phân phối công việc qua NHIỀU goroutine (song song hóa)
Fan-in:  GỘP kết quả từ nhiều goroutine trở lại một channel
```

```go
// fan-in: gộp nhiều channel thành một
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 }   // chuyển tiếp giá trị của mỗi channel tới out
        }(ch)
    }
    go func() { wg.Wait(); close(out) }()    // đóng out khi tất cả nguồn đã cạn
    return out
}
```

## Pipeline — các giai đoạn nối với nhau bằng channel

```go
// mỗi giai đoạn là một goroutine: nhận từ một channel đầu vào, gửi tới một channel đầu ra
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
}
// kết hợp: square(generate(1,2,3)) → một pipeline streaming
for result := range square(generate(1, 2, 3)) { fmt.Println(result) }
```

Một **pipeline** nối các giai đoạn xử lý qua channel — dữ liệu chảy qua, mỗi giai đoạn biến đổi nó một cách concurrent.

## Rate limiting

```go
limiter := time.Tick(200 * time.Millisecond)   // một tick mỗi 200ms
for req := range requests {
    <-limiter                                    // chờ tick tiếp theo trước khi tiếp tục
    go handle(req)                                // → tối đa 5 request/giây
}
```

## Hủy với context (xuyên suốt)

```go
select {
case result := <-work:
case <-ctx.Done():    return   // dừng khi bị hủy — ngăn rò rỉ
}
```

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

Các pattern concurrency này là bộ công cụ thực tế để xây dựng các hệ thống Go concurrent thực, biến goroutine và channel thô thành các giải pháp có cấu trúc, đúng đắn cho các vấn đề lặp lại. **Worker pool** đặc biệt quan trọng — nó giới hạn concurrency để bảo vệ các tài nguyên hữu hạn (kết nối database, giới hạn rate của API, bộ nhớ), ngăn sai lầm phổ biến là sinh ra goroutine không giới hạn làm cạn kiệt hệ thống. **Fan-out/fan-in** song song hóa công việc và gộp kết quả; **pipeline** mô hình hóa các biến đổi dữ liệu streaming một cách sạch sẽ; **rate limiting** kiểm soát throughput.

Kết hợp với **hủy dựa trên context** (để tránh rò rỉ goroutine), các pattern này là cách các dịch vụ Go production xử lý concurrency một cách an toàn và hiệu quả.

Hiểu chúng — và đặc biệt biết giới hạn concurrency bằng worker pool thay vì khởi chạy goroutine không giới hạn — là dấu hiệu của năng lực Go senior và là một chủ đề phỏng vấn nâng cao thường gặp, vì concurrency ngây thơ (goroutine không giới hạn, rò rỉ, race) là một nguồn lỗi production phổ biến.