Có một service Go mình từng chạy, CPU không cao, RAM không phình, vậy mà p99 cứ nhảy múa mỗi vài giây. Mở pprof lên thì thủ phạm không nằm ở code nghiệp vụ, mà ở GC: mỗi request cấp phát vài chục KB buffer rồi vứt đi, vài nghìn request mỗi giây là rác chất thành núi.
Chỗ này sync.Pool đáng được thử. Nhưng nó cũng là món dễ dùng sai nhất trong standard library, nên mình đi từ vấn đề trước.
Vì sao cấp phát nhiều lại làm chậm
Mỗi lần make([]byte, 64*1024) hay new(bytes.Buffer) là thêm việc cho allocator, và quan trọng hơn là thêm việc cho GC. Go GC chạy song song nên ít khi dừng cả chương trình, nhưng nó vẫn ăn CPU và kéo theo write barrier. Cấp phát càng dày, chu kỳ GC càng thường.
Ảnh: nhiều object sống rất ngắn cùng đổ về một máng rác, robot GC không kịp dọn — chính là tình huống mỗi request cấp phát buffer mới rồi bỏ đi — ảnh minh hoạ do AI tạo (Grok Imagine)
Trước khi nghĩ tới pool, mình luôn kiểm tra xem biến có thật sự chạy lên heap không. Bài Escape analysis trong Go — vì sao biến chạy lên heap mình viết hôm trước là bước 1: nếu object nằm được trên stack thì không cần pool gì hết.
sync.Pool hoạt động thế nào
Ý tưởng đơn giản: thay vì vứt object, bạn trả nó vào kho, request sau lấy ra xài lại.
var bufPool = sync.Pool{
New: func() any {
return bytes.NewBuffer(make([]byte, 0, 4096))
},
}
func render(w io.Writer, data []Item) error {
buf := bufPool.Get().(*bytes.Buffer)
buf.Reset() // luôn reset trước khi dùng
defer bufPool.Put(buf)
if err := json.NewEncoder(buf).Encode(data); err != nil {
return err
}
_, err := w.Write(buf.Bytes())
return err
}
Mấy điểm cần nhớ:
Gettrả về object cũ nếu có, không thì gọiNew.Puttrả object về kho. Bên trong, pool chia theo từng P (processor), nên ít tranh chấp lock.- Pool không đảm bảo giữ object. GC có thể dọn sạch pool bất cứ lúc nào (từ Go 1.13 có victim cache nên object sống thêm một chu kỳ GC, nhưng vẫn không hứa gì).
Nghĩa là pool là cache cho object tạm, không phải nơi lưu trạng thái. Bạn không được phụ thuộc vào việc lấy lại đúng object đã bỏ vào.
Ảnh: chiếc hộp được mượn, lau sạch rồi trả về kệ — tương ứng vòng đời Get, Reset, dùng, Put của object trong pool — ảnh minh hoạ do AI tạo (Grok Imagine)
Đo trước khi tin
Pool không miễn phí: mỗi Get/Put cũng tốn vài chục nanosecond và làm code rối hơn. Cách duy nhất để biết có lời hay không là benchmark:
func BenchmarkNoPool(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
buf := new(bytes.Buffer)
buf.Grow(4096)
buf.WriteString("hello")
}
}
func BenchmarkPool(b *testing.B) {
b.ReportAllocs()
for i := 0; i < b.N; i++ {
buf := bufPool.Get().(*bytes.Buffer)
buf.Reset()
buf.WriteString("hello")
bufPool.Put(buf)
}
}
Chạy go test -bench . -benchmem, nhìn cột allocs/op và B/op. Ở service thật của mình, allocs/op của đoạn render JSON giảm từ 6 xuống 1, tần suất GC giảm gần một nửa và p99 êm hẳn. Nhưng với object nhỏ, vài chục byte, mình từng đo thấy pool còn chậm hơn cấp phát thẳng. Con số mới là thứ quyết định, cảm giác thì không.
Muốn tìm đúng chỗ cấp phát nhiều để đo, đi theo pprof trong Go — tìm thủ phạm ngốn CPU và RAM với profile alloc_objects. Còn nếu tò mò chuyện tương tự bên .NET, tham khảo tài liệu ArrayPool trong docs của Microsoft để thấy cùng một ý tưởng ở ngôn ngữ khác.
Ba cái bẫy hay dính
1. Quên reset. Object lấy từ pool còn nguyên dữ liệu của lần dùng trước. Quên Reset() thì request B có thể đọc nhầm dữ liệu của request A. Đây là lỗi bảo mật chứ không chỉ là bug, nên mình thường gói Get và Reset vào một hàm helper để khỏi quên.
2. Giữ tham chiếu sau khi Put. Đoạn này mới nguy hiểm:
buf := bufPool.Get().(*bytes.Buffer)
defer bufPool.Put(buf)
buf.WriteString("data")
return buf.Bytes() // SAI: slice trỏ vào bộ nhớ sắp bị người khác ghi đè
Trả buf.Bytes() ra ngoài rồi Put, goroutine khác lấy buffer đó ghi đè lên, và caller đọc ra rác. Muốn trả dữ liệu ra thì copy trước: append([]byte(nil), buf.Bytes()...).
3. Pool buffer phình to. Một request hiếm hoi cần 50MB buffer, Put vào pool, từ đó mỗi lần lấy ra đều mang theo 50MB. Cách xử lý của standard library (như trong fmt) là bỏ không trả về pool nếu buffer quá lớn:
if buf.Cap() > 64<<10 {
return // để GC dọn, đừng trả vào pool
}
bufPool.Put(buf)
Ảnh: chiếc hộp trả về mà chưa được lau, người kế tiếp dùng phải đồ bẩn — hậu quả của việc quên Reset khi lấy object từ pool — ảnh minh hoạ do AI tạo (Grok Imagine)
Khi nào nên dùng, khi nào thôi
Dùng khi object tạo ra đắt hoặc to (buffer, encoder, struct lớn), sống ngắn, và được cấp phát với tần suất cao trên đường nóng. Đừng dùng cho object nhỏ, object có kết nối hay trạng thái (connection DB cần pool riêng có giới hạn và health check, sync.Pool không làm được việc đó), hay khi chưa có benchmark chứng minh.
Thứ tự mình hay làm: đo bằng pprof, thử giảm cấp phát bằng cách code lại (cấp trước make với capacity, tránh chuyển string/[]byte thừa), rồi mới đến sync.Pool. Phần lớn lần, hai bước đầu đã đủ.
Chuyện "đo trước rồi mới tối ưu" cũng đúng bên Rust, như trong Tokio chậm bất thường — một dòng blocking giấu trong async: thủ phạm hiếm khi nằm ở chỗ mình đoán.
Còn bạn, có lần nào dùng sync.Pool mà hóa ra chậm hơn không? Mình tò mò đã gặp trường hợp nào ngược với kỳ vọng.
📋 Phụ lục thuật ngữ
| Thuật ngữ | Giải thích ngắn |
|---|---|
| sync.Pool | Kho object tạm trong standard library, an toàn khi nhiều goroutine dùng chung |
| GC (garbage collector) | Bộ dọn rác tự động, thu hồi bộ nhớ không còn tham chiếu |
| Escape analysis | Bước compiler quyết định biến nằm trên stack hay heap |
| Victim cache | Tầng đệm giúp object trong pool sống thêm một chu kỳ GC |
| allocs/op | Số lần cấp phát trên mỗi vòng benchmark |
| p99 | Độ trễ mà 99% request nhanh hơn hoặc bằng |
