Khi nào bạn dùng package sync thay vì channel?

Question

Accepted Answer

Go cung cấp hai cách tiếp cận cho an toàn concurrency: **channel** ("chia sẻ bộ nhớ bằng cách giao tiếp") và **package `sync`** (mutex/khóa để bảo vệ bộ nhớ chung trực tiếp). Mặc dù Go có triết lý ưu tiên channel, các primitive sync thường là lựa chọn đơn giản hơn, hiệu quả hơn để bảo vệ trạng thái chung.

## sync.Mutex — bảo vệ trạng thái chung với một khóa

```go
type Counter struct {
    mu    sync.Mutex
    count int
}

func (c *Counter) Increment() {
    c.mu.Lock()           // chiếm khóa — chỉ một goroutine một lúc qua được đây
    defer c.mu.Unlock()    // giải phóng khi return (defer đảm bảo luôn xảy ra)
    c.count++              // an toàn — vùng tới hạn (critical section) được bảo vệ
}
```

Một `Mutex` đảm bảo chỉ một goroutine truy cập dữ liệu được bảo vệ một lúc, ngăn data race. Pattern `Lock()`/`defer Unlock()` là idiomatic.

## sync.RWMutex — nhiều reader HOẶC một writer

```go
type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}
func (c *Cache) Get(key string) string {
    c.mu.RLock()           // khóa ĐỌC — nhiều reader được phép đồng thời
    defer c.mu.RUnlock()
    return c.data[key]
}
func (c *Cache) Set(key, value string) {
    c.mu.Lock()            // khóa GHI — độc quyền
    defer c.mu.Unlock()
    c.data[key] = value
}
```

`RWMutex` cho phép đọc đồng thời nhưng ghi độc quyền — lý tưởng cho dữ liệu đọc-nhiều như cache.

## Các primitive sync khác

```go
sync.WaitGroup           // chờ một nhóm goroutine hoàn tất (Add/Done/Wait)
sync.Once                // chạy thứ gì đó CHÍNH XÁC một lần (lazy init, singleton)
  var once sync.Once
  once.Do(initialize)    // initialize chỉ chạy ở lần gọi đầu tiên, mãi mãi
sync.Map                 // một map concurrent (các trường hợp chuyên biệt)
atomic.AddInt64(&n, 1)   // thao tác atomic không khóa cho các bộ đếm đơn giản
```

## Khi nào dùng sync vs channel

```text
Dùng sync (Mutex/RWMutex/atomic) khi:
  ✓ Bảo vệ TRẠNG THÁI chung đơn giản (một bộ đếm, một cache, một map)
  ✓ Logic là "canh giữ dữ liệu này" — khóa đơn giản và nhanh hơn channel ở đây
  ✓ Dữ liệu đọc-nhiều (RWMutex), khởi tạo một lần (Once), bộ đếm đơn giản (atomic)

Dùng channel khi:
  ✓ GIAO TIẾP/truyền dữ liệu giữa các goroutine, báo hiệu, điều phối
  ✓ Pipeline, phân phối worker, chuyển giao quyền sở hữu
```

Quy tắc thực tế: **"Đừng giao tiếp bằng cách chia sẻ bộ nhớ" là một hướng dẫn, không phải giáo điều.** Để chỉ đơn giản bảo vệ trạng thái chung, một mutex rõ ràng và hiệu quả hơn so với việc bẻ cong logic thành channel.

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

Biết khi nào dùng package `sync` so với channel là một dấu hiệu then chốt của sự trưởng thành về concurrency trong Go.

Trong khi Go đề cao channel ("chia sẻ bộ nhớ bằng cách giao tiếp"), đây là một hướng dẫn — và một sai lầm phổ biến là ép channel vào nơi mà một **mutex** đơn giản sẽ rõ ràng và nhanh hơn.

Package `sync` là công cụ đúng, idiomatic để **bảo vệ trạng thái chung** (bộ đếm, cache, map): mutex cho truy cập độc quyền, `RWMutex` cho dữ liệu đọc-nhiều, `WaitGroup` để chờ các goroutine, `Once` cho khởi tạo một lần, và `atomic`/`sync.Map` cho các trường hợp chuyên biệt.

Hiểu rằng channel vượt trội ở *giao tiếp và điều phối* trong khi các primitive sync vượt trội ở *canh giữ bộ nhớ chung* — và chọn công cụ phù hợp thay vì dùng channel một cách giáo điều — dẫn đến code concurrent đơn giản hơn, hiệu quả hơn, đúng đắn hơn.

Sự phán đoán này chính là điều phân biệt các lập trình viên Go giàu kinh nghiệm và là một chủ đề phỏng vấn nâng cao thường gặp.