Cuối tháng 10 mình nhận một ticket mô tả ngắn gọn tới mức khó tin: "sáng ra API chậm, tầm 10 giờ tự khỏi". Không alert, không 500, không exception. Grafana hiện CPU 6%, RAM 400MB trên con VM 4GB. Mọi dashboard đều xanh. Và đúng như ticket nói, tới trưa thì mọi thứ lại bình thường.

Ba ngày sau mình mới tin là nó không tự khỏi, nó chỉ hết thủ phạm. Bài này kể lại đúng mạch điều tra đó, vì cái bẫy gặp phải là bẫy rất nhiều code Go đang dính mà không biết: một dòng blocking call trong handler làm hàng trăm goroutine khác chết đói, dù CPU gần như rảnh.

Triệu chứng: chỉ p99 chết, mọi thứ khác khoe

Metric duy nhất có vấn đề là p99 của một endpoint nội bộ /report/download và cả endpoint health check của nó. p50 vẫn 40ms, p99 nhảy lên 30 giây. Số request vẫn đều. Nhìn vào thì giống mạng, giống DNS, giống đứa nào đó làm rớt packet.

Manh mối thật nằm ở cái này: health check time out, nhưng CPU không hề tăng theo. Hệ thống bị treo mà không ai đốt CPU. Đó là dấu hiệu của starvation (chết đói), không phải overload (quá tải). Hai thứ này cực dễ lẫn nhau, và cách sửa ngược nhau hoàn toàn: overload thì thêm tài nguyên, starvation thì blocking không cho goroutine được chạy.

Mình từng đọc một ca tương tự ở phía .NET, thread pool starvation: CPU 8% mà API đứng hình, và cái pattern "tài nguyên rảnh mà service nghen" y chang vậy. Chỉ khác là ở Go, người ta hiếm khi nghĩ tới nó vì ai cũng tin goroutine chạy song song vô tư. Riêng chuyện RAM và heap thì mình đã sai một lần rồi, lần đó container bị OOMKilled dù heap còn trống vì tin vào số heap mà không nhìn số RSS. Lần này mình không tin dashboard nữa, đi thẳng vào goroutine.

Điều tra: đếm goroutine trước khi đọc code

Việc đầu tiên mình làm không phải mở source, mà mở pprof. go tool pprof http://localhost:6060/debug/pprof/goroutine?debug=1 lúc 9h sáng cho ra con số ~3.200 goroutine, so với baseline 62 lúc trưa. Trong đó khoảng 2.800 con nằm ở đúng một dòng:

#	0x5e1c24	runtime.gopark+0xc4
#	0x4d9b04	internal/poll.runtime_pollWait+0x84
#	0x4dbd1c	internal/poll.(*FD).Read+0x1bc
#	0x4dd5a8	os.(*File).Read+0x48
#	0x4de9f0	archive/zip.(*File).Open+0x1ac   <- handler download

Nghĩa là: một đám goroutine đang chờ Read trên file zip. Nghe thì hợp lý, endpoint download thì phải đọc file. Vấn đề là file đó nằm trên một NFS mount chung, và mỗi request zip 200-400 file con.

Root cause: mọi goroutine ngồi chờ trên cùng một hàng đợi thread

Ở Go, khi goroutine gọi một syscall blocking, runtime sẽ "bàn giao" (handoff) cục P đang giữ cho M (thread) khác, để goroutine khác có P mà chạy. Bàn giao này có chi phí và có giới hạn: mỗi handoff phải gọi entersyscall, cộng thêm thời gian tạo/đánh thức thread hệ điều hành. Với vài chục call cùng lúc thì không ai thấy. Với vài nghìn call cùng lúc lên một NFS chậm 150-300ms mỗi lần đọc, chi phí này ăn hết scheduler.

Mình dựng lại bằng một test nhỏ để chắc chắn mình không tự huyễn: server chỉ có 2 P (GOMAXPROCS=2), 40 request gọi một dịch vụ chậm 200ms mỗi lần, song song với một endpoint /ping rất nhẹ.

var store = blobStore{delay: 200 * time.Millisecond}

mux.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
	io.Copy(io.Discard, r.Body)
	w.Write([]byte("pong"))
})
mux.HandleFunc("/download", func(w http.ResponseWriter, r *http.Request) {
	// Get() = time.Sleep(200ms), tượng trưng cho syscall.Read trên NFS
	b, _ := store.Get(r.URL.Query().Get("file"))
	w.Write(b)
})

Kết quả trên máy mình, Go 1.27:

  • Block không giới hạn: /ping n=185, avg 0ms, max 0ms. Không sao.
  • Block nhưng chỉ cho 4 download cùng lúc (channel làm semaphore): /ping n=184, max 0ms. Cũng không sao, nhưng download avg tăng từ 200ms lên 1.102ms, max 2.006ms, vì request phải xếp hàng chờ tới lượt.

Hay ở chỗ: GOMAXPROCS=2 chịu nổi 40 call blocking. Runtime tạo thêm thread khi cần. Nghĩa là "goroutine bị chặn làm chết cả process" không phải chuyện của con số 40, mà là chuyện của hàng nghìn và của một tài nguyên dùng chung ai cũng đụng vào.

Bẫy phụ: CPU-bound thì lại có chuyện khác

Trong lúc dò, mình thử luôn trường hợp ngược lại: goroutine chạy tính toán nặng, không hề blocking. 40 goroutine tính vòng lặp trên GOMAXPROCS=2, một goroutine đo độ trễ mỗi 5ms:

goroutine "health check" chạy mỗi 5ms, đo gap thực tế
for i := 0; i < workers; i++ {
	go func() { sink.Add(int64(burn(iters))) }()
}

Ba lần chạy liên tiếp: gap max 43,0ms / 42,4ms / 48,0ms. So với nhịp 5ms thì chậm gần 10 lần. Go có preemption từ 1.14 (dựa trên tín hiệu), nhưng preemption theo tín hiệu chỉ cắt được ở điểm an toàn, và goroutine không nhường P thì nó vẫn làm ăn hết quantum. Đây đúng là lý do các goroutine nặng tay nên được giới hạn bằng worker pool hoặc runtime.Gosched ở vòng lặp dài. Không phải "cứ go là xong".

Fix: ba tầng, làm từ rẻ tới đắt

Tầng 1, giới hạn concurrency ở chỗ hệ quả của nó chấp nhận được. Pattern semaphore bằng channel, đúng cái mình vừa đo ở trên:

var limitCh = make(chan struct{}, 4) // 4 download cùng lúc, đặt dưới sức NFS

mux.HandleFunc("/download", func(w http.ResponseWriter, r *http.Request) {
	limitCh <- struct{}{}
	defer func() { <-limitCh }()

	b, err := store.Get(r.URL.Query().Get("file"))
	if err != nil {
		http.Error(w, "busy", http.StatusServiceUnavailable)
		return
	}
	w.Write(b)
})

Đánh đổi rõ ràng: latency của /download tăng (2 giây thay vì 200ms khi có 40 request), nhưng /ping và health check sống. Với một endpoint download file nặng thì đây là đánh đổi đúng, vì thà nó chậm còn hơn cả service nghen.

Tầng 2, gộp request trùng. Nguyên nhân gốc là cả 40 request đều hỏi cùng một file zip chưa có cache, nên cùng đọc lại từ đầu. Gom các request trùng lại thì 40 lần đọc thành 1. Mình có viết kỹ cách làm ở singleflight trong Go: gộp request trùng, chống cache stampede, và đây là ứng dụng thực tế nhất của nó mà mình từng gặp.

Tầng 3, bỏ blocking khỏi đường request. Download file lớn thì nên trả 202 kèm job id, đẩy việc zip sang worker riêng với context.WithTimeout, client poll trạng thái. Ở đây mình không làm ngay vì tầng 1 đã đủ cắt sự cố, nhưng đã ghi vào backlog kèm tiêu chí: khi số file trung bình mỗi zip vượt 500 thì làm.

Bài học

  • CPU thấp không có nghĩa là service khoẻ. Starvation và overload là hai bệnh khác nhau, cùng triệu chứng "chậm". Đo CPU trước khi tin vào dashboard.
  • Goroutine là rẻ, nhưng không miễn phí. Chỗ goroutine chờ là một tài nguyên dùng chung (NFS, DB, HTTP upstream). Tài nguyên dùng chung phải có giới hạn, đặt ở tầng mà hệ quả còn chấp nhận được.
  • Đếm runtime.NumGoroutine() như đếm connection pool. Con số này tăng đều đặn theo giờ là dấu hiệu sớm, rẻ hơn nhiều so với chờ alert p99. Mình gắn thêm một gauge goroutine lên dashboard, đặt ngưỡng cảnh báo ở 10 lần baseline, và từ đó tới giờ chưa phải đoán nữa.
  • p99 là chỉ số bắt buộc cho handler có I/O. p50 và avg đều ổn trong cả 3 ngày sự cố, chỉ p99 kêu.
  • Allocation trong đường nóng thì ít ai nghĩ tới, nhưng nó là thứ tiếp theo mình soi. Bản zip cũ cấp phát một buffer mới cho mỗi file; tái dùng object bằng sync.Pool là bước mình làm sau khi đã chặn xong sự cố.

Hai tuần sau sự cố, mình kiểm tra lại cái NFS mount, phát hiện nó nằm trên hạ tầng của team khác và bị bật tính năng dedupe từ đúng ngày ticket mở. Sự cố của mình hoá ra là triệu chứng của một thay đổi ở hệ thống không ai báo. Nếu chỉ đọc code Go của mình thì sẽ không bao giờ tìm ra, và cũng không nên: giới hạn concurrency là việc của mình, dù hàng xóm có làm gì đi nữa.

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