Có một buổi chiều mình ngồi nhìn cái CI xanh rờn mà trong lòng không vui. 512 test, tất cả pass, coverage 80%, reviewer ký duyệt. Ba tuần sau, production trả về một con số vô lý: hai request đọc cùng một khoá, một cái thấy dữ liệu cũ, một cái thấy dữ liệu chưa commit. Log sạch, không một dòng error. Kiểu bug đó không phải bug logic — nó là data race, và test của mình không có khả năng nhìn thấy nó.

Data race là gì, và vì sao test thường không bắt được

Data race xảy ra khi hai goroutine truy cập cùng một vùng nhớ, ít nhất một trong hai là ghi, và giữa chúng không có đồng bộ nào. Kết quả không phải "sai lúc nào cũng sai" mà là "sai theo xác suất". Chạy trên máy 8 core, scheduler xếp lịch khác nhau mỗi lần, nên một đoạn code có thể đúng 10.000 lần rồi sai đúng một lần trên production đông người dùng.

Test thường trượt qua vì ba lý do: máy CI ít core nên ít cơ hội chạy song song thật, dữ liệu test quá nhỏ nên vòng lặp xong trước khi goroutine kia kịp chen vào, và quan trọng nhất — test chỉ kiểm tra kết quả cuối, không kiểm tra quá trình.

Một ví dụ nhỏ, sai rất khó thấy

Đây là kiểu code mình gặp nhiều nhất: một cache in-memory bằng map, đọc ghi từ nhiều goroutine.

type Cache struct {
    m map[string]string
}

func (c *Cache) Get(k string) (string, bool) {
    v, ok := c.m[k]  // đọc map không có lock
    return v, ok
}

func (c *Cache) Set(k, v string) {
    c.m[k] = v      // ghi map không có lock
}

Chạy cái này với vài chục goroutine, khả năng cao là... chẳng thấy gì. Go runtime chỉ panic khi phát hiện map đang bị ghi đồng thời (concurrent map writes), còn đọc song song với ghi thì im lặng. Và nếu map nhỏ, chưa rehash, thì gần như không bao giờ panic. Thế là nó sống sót qua CI, qua QA, tới production.

Bật race detector: một flag, đổi cả cách nhìn

Go có sẵn công cụ này trong toolchain, không cần cài gì. Chỉ cần thêm -race:

go test -race ./...
go run -race ./cmd/server

Bật lên, chạy lại đúng bộ test cũ, mình nhận về một tràng cảnh báo. Dạng output nó như vầy:

==================
WARNING: DATA RACE
Write at 0x00c0000b4010 by goroutine 12:
  main.(*Cache).Set()
      /app/cache.go:14 +0x44

Previous read at 0x00c0000b4010 by goroutine 9:
  main.(*Cache).Get()
      /app/cache.go:9 +0x38

Goroutine 12 (running) created at:
  main.main()
      /app/main.go:31 +0x9c
==================

Đọc cái này đúng thì nó là bản đồ: hai vị trí truy cập, tên hàm, số dòng, và goroutine nào tạo ra chúng. Đừng đọc từ trên xuống như stack trace crash — hãy tìm hai dòng có chữ Write at và Previous read at trước, đó là chỗ đánh nhau; phần "created at" chỉ để biết ai sinh ra goroutine.

Về cách tổ chức goroutine cho gọn, mình có viết kỹ ở bài errgroup trong Go: chạy song song, bắt lỗi, huỷ cả nhóm — ở đó cách huỷ nhóm cũng là một dạng đồng bộ gián tiếp mà nhiều người quên tính vào.

Sửa: chọn đúng công cụ đồng bộ

Sửa race không phải "thêm mutex cho chắc". Có ba lựa chọn, khác nhau về chi phí và mục đích:

type Cache struct {
    mu sync.RWMutex
    m  map[string]string
}

func (c *Cache) Get(k string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    v, ok := c.m[k]
    return v, ok
}

func (c *Cache) Set(k, v string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.m[k] = v
}

RWMutex hợp với cache vì đọc nhiều hơn ghi rất nhiều. Nếu là bộ đếm đơn giản thì atomic rẻ hơn nhiều. Nếu muốn tránh lock hẳn thì sync.Map có ích cho trường hợp key chỉ ghi một lần rồi đọc mãi — nhưng với cache có xoá và cập nhật, nó thường chậm hơn RWMutex chứ không nhanh hơn. Cái này mình đã đo và bất ngờ.

Với dữ liệu cần gộp nhiều request trùng nhau, có khi cách hay nhất là để singleflight lo phần khoá theo key — như trong bài singleflight trong Go: gộp request trùng, chống cache stampede.

Ba cái bẫy mình từng dính

Một: race detector không chứng minh là không có race. Nó chỉ báo những race xảy ra trong lần chạy đó. Đoạn code đọc ghi hiếm khi chồng lên nhau vẫn có thể lọt. Cho nên -race là điều kiện cần, không phải điều kiện đủ.

Hai: race trên dữ liệu lớn hơn một word. Cộng dồn tiền bằng balance += amount trên struct có nhiều field có thể bị xé (torn write) — runtime không panic, giá trị lưu vào là giá trị lai giữa hai lần ghi. Loại này chỉ race detector bắt được, mắt thường nhìn code thấy hoàn toàn hợp lý.

Ba: chạy -race trong CI nhưng test lại mock hết. Nếu test không đụng database thật, không có goroutine thật chồng lên nhau, thì race detector chẳng có gì để bắt. Cách mình làm bây giờ là để một job riêng chạy go test -race -count=5 trên bộ test integration với database thật — cách dựng loại test này mình kể ở Testcontainers — integration test với database thật, không cần mock.

Đưa vào quy trình, đừng để thành "lần sau nhớ bật"

Mình chốt ba việc trong repo, tất cả đều tự động:

  • Job CI riêng go test -race ./... chạy song song với job test thường, không chặn merge nhưng báo lên Slack. -race làm test chậm 3-10 lần nên đừng gộp vào job chính.
  • go vet bật trước go test; nó bắt được vài kiểu copy lock (sync.Mutex truyền by value) mà đọc code rất dễ bỏ qua.
  • Một test stress nhỏ: chạy hàm nghi ngờ với 100 goroutine, -count=10, trên máy CI có ít nhất 4 core. Nếu không có core, race gần như vô hình.

Bài học mình rút ra sau vụ đó không phải "nhớ dùng mutex". Mà là: test xanh chỉ nói code chạy đúng với thứ tự thực thi mà máy này đã chọn. Race detector là công cụ duy nhất trong toolchain Go nói cho mình biết về những thứ tự khác mà mình chưa từng thấy. Bật nó không làm code chậm đi trên production, chỉ làm CI chậm thêm vài phút — đổi lại là một lớp bug biến mất hẳn khỏi đường đi của mình.

Xem các bài viết khác