---
title: "Connection pool là gì, vì sao service Go treo dù database còn rảnh"
description: "Service Go timeout hàng loạt trong khi database vẫn rảnh? Bài này giúp bạn hiểu connection pool trong Go hoạt động ra sao và cách chỉnh pool cho đúng tải."
canonical: "https://200lab.io/blog/connection-pool-la-gi"
published: "2026-11-16T07:42:55Z"
updated: "2026-11-16T07:42:55Z"
authors: ["Việt Trần"]
tags: ["Backend", "Golang"]
reading_minutes: 19
access: "public"
---

Giả sử giờ cao điểm, API của bạn timeout hàng loạt, nhưng khi mở dashboard database thì CPU vẫn thấp và số kết nối còn xa giới hạn. Database lúc này đâu có bận, các request thực ra đang xếp hàng ngay trong service Go để chờ tới lượt lấy kết nối.

**Connection pool là nhóm kết nối database được mở sẵn, service lấy ra dùng cho từng query rồi trả lại để dùng tiếp, thay vì mỗi request lại mở rồi đóng một kết nối mới.**

Trong bài này, mình sẽ giải thích thư viện chuẩn `database/sql` của Go quản lý connection pool ra sao, các thông số cấu hình có ý nghĩa gì, và làm sao chẩn đoán khi pool bị nghẽn. Mình cũng chạy một demo bằng [ngôn ngữ Go](/blog/golang-la-gi) với PostgreSQL 17 để xem lần lượt các tình huống: pool thiếu kết nối, leak kết nối, rồi tới lúc chỉnh lại cho hợp lý.

## Connection pool là gì và vì sao database/sql cần nó

Nhiều bạn mới học Go hay nhầm `*sql.DB` là một kết nối đơn lẻ tới [hệ quản trị database](/blog/database-la-gi). Theo [tài liệu package database/sql](https://pkg.go.dev/database/sql), `*sql.DB` thực ra là một connection pool, quản lý nhiều kết nối ở phía sau. Pool tự mở kết nối vật lý, giữ lại, cấp cho từng query và đóng khi cần.

Giữ sẵn pool giúp tiết kiệm tài nguyên, nhất là khi làm việc với [database PostgreSQL](/blog/postgresql-la-gi). Theo [tài liệu PostgreSQL 17 về thiết lập kết nối](https://www.postgresql.org/docs/17/connect-estab.html), PostgreSQL dùng kiến trúc "process per user": mỗi lần client kết nối vào, postmaster lại tạo một process hệ điều hành riêng cho kết nối đó.

PostgreSQL còn giới hạn tổng số kết nối đồng thời bằng tham số `max_connections`, mặc định thường là 100 theo [tài liệu cấu hình kết nối PostgreSQL 17](https://www.postgresql.org/docs/17/runtime-config-connection.html). Vì vậy, bạn chỉ nên tạo một `*sql.DB` duy nhất lúc service khởi động rồi dùng chung cho tới khi service tắt.

## Một query dùng và trả kết nối trong pool ra sao

Khi code gọi một hàm query, pool sẽ cấp một kết nối cho [goroutine](/blog/goroutines-la-gi) đang xử lý request đó. Đầu tiên, pool tìm một kết nối `Idle` (đang rảnh, nằm sẵn trong pool). Nếu có, pool giao ngay cho goroutine và chuyển kết nối sang `InUse` (đang được dùng).

Nếu không còn kết nối `Idle` nào, pool so tổng số kết nối đang mở với giới hạn `MaxOpenConns`. Chưa chạm trần thì driver mở thêm một kết nối vật lý mới tới PostgreSQL. Còn nếu đã chạm `MaxOpenConns`, goroutine phải đứng chờ cho tới khi có kết nối khác được trả về.

![Vòng đời một kết nối trong Go database/sql từ lúc được lấy ra đến khi trả về pool.](https://assets.200lab.io/sha256/04/04c69bf0ed4c439c88bc77d994f6e5fb5832b10f7586f2c7370485f2ceae8d46/generations/655e698a078585394366fe554d14bb5f2d030f579980489f2f1e4d4b1d53809e)

Câu SQL chạy xong trên server không có nghĩa là kết nối đã quay về pool. Kết nối chỉ được trả lại khi bạn đọc hết dữ liệu (`rows.Next()` trả về `false`) hoặc gọi `rows.Close()`, hay kết thúc transaction bằng `tx.Commit()` hay `tx.Rollback()`. Khi về pool, kết nối quay lại trạng thái `Idle` chờ query kế tiếp, hoặc bị đóng luôn nếu pool đã giữ đủ số kết nối rảnh tối đa.

## SetMaxOpenConns, SetMaxIdleConns và SetConnMaxLifetime

Package `database/sql` có bốn hàm cấu hình chính, đều gọi trên `*sql.DB`. `SetMaxOpenConns(n)` giới hạn tổng số kết nối được mở cùng lúc, tính cả `InUse` lẫn `Idle`. Mặc định là 0, tức không giới hạn. Theo [tài liệu hướng dẫn Managing connections của Go](https://go.dev/doc/database/manage-connections), giới hạn này hoạt động như một semaphore (cơ chế giới hạn số tác vụ được dùng một tài nguyên cùng lúc), nên đặt thấp quá thì request sẽ phải xếp hàng.

![Bốn thông số cấu hình quan trọng để kiểm soát connection pool trong Go.](https://assets.200lab.io/sha256/b1/b1600970c470be9f11c17e038cf2af8bf82ee50cec47d25af6ba483d83da4655/generations/95e958e60c58e6667fb5b6c9d9e4d55aee90a3039b397fc1535d41651afd4a38)

`SetMaxIdleConns(n)` quy định pool được giữ lại tối đa bao nhiêu kết nối rảnh để dùng lại. Mặc định hiện tại là 2 (tài liệu có ghi con số này có thể đổi ở các bản Go sau). Nếu đã đặt `MaxOpenConns` (lớn hơn 0) mà nó nhỏ hơn giá trị này, thư viện sẽ tự hạ `MaxIdleConns` xuống bằng `MaxOpenConns`. Khi có nhiều tác vụ chạy song song, tăng con số này lên giúp pool khỏi phải đóng rồi mở lại kết nối liên tục.

Hai hàm còn lại, `SetConnMaxLifetime(d)` và `SetConnMaxIdleTime(d)`, giới hạn tuổi thọ của kết nối theo thời gian. `SetConnMaxLifetime(d)` đặt thời gian tối đa một kết nối được dùng lại, tính từ lúc mở (hữu ích khi database đứng sau load balancer). Kết nối quá hạn không nhất thiết bị đóng ngay, có thể đợi tới trước lần dùng kế tiếp mới đóng. `SetConnMaxIdleTime(d)` quy định một kết nối được nằm rảnh bao lâu thì bị đóng. Hàm này hay đi cùng `SetMaxIdleConns` lớn, để lúc vắng tải pool tự nhả bớt kết nối.

## Chạy thử golang connection pool với PostgreSQL 17

Mình chạy demo này trên máy local, không phải môi trường production, với `go1.27.3`, PostgreSQL 17.11 (`max_connections=100`) và [driver pgx cho PostgreSQL](https://github.com/jackc/pgx) bản v5.13.0 qua package `stdlib`. Mỗi ca tạo một `*sql.DB` mới rồi gửi 400 request trong 1 giây (cứ 2,5 ms một request). Mỗi request chạy `SELECT pg_sleep(0.02), 1` (tốn 20 ms trên DB) với timeout 500 ms. Trong lúc chạy, chương trình đọc `pg_stat_activity` mỗi 50 ms, chụp `db.Stats()` mỗi 250 ms và đo CPU của PostgreSQL qua `/proc`, tính theo phần trăm của một core.

Mình cùng xem đoạn code chính nha:

```go
// excerpt from main.go
// good: every row set and transaction is closed on every path.
func good(ctx context.Context, db *sql.DB, i int) error {
	rows, err := db.QueryContext(ctx, query)
	if err != nil {
		return err
	}
	defer rows.Close()
	for rows.Next() {
	}
	return rows.Err()
}

// leaky: on some paths it returns early and forgets to close rows or the tx.
func leaky(ctx context.Context, db *sql.DB, i int) error {
	if i%40 == 0 { // "update stock" path: tx is never committed or rolled back
		tx, err := db.BeginTx(context.Background(), nil)
		if err != nil {
			return err
		}
		if _, err := tx.Exec("SELECT 1"); err != nil {
			return err
		}
		return nil // BUG: missing tx.Commit() / tx.Rollback()
	}
	rows, err := db.Query(query) // no request context
	if err != nil {
		return err
	}
	if i%25 == 0 { // "out of stock" early return
		return nil // BUG: missing rows.Close()
	}
	defer rows.Close()
	for rows.Next() {
	}
	return rows.Err()
}
```

Hàm `main` chạy các hàm xử lý trên với từng cấu hình pool, mỗi ca có một tên như `case1_small_pool` để bạn dò trong output bên dưới:

```go
func main() {
	db, _ := sql.Open("pgx", dsn)
	var ver string
	db.QueryRow("SHOW server_version").Scan(&ver)
	db.Close()
	fmt.Printf("%s, PostgreSQL %s, pgx v5 stdlib\n", runtime.Version(), ver)
	fmt.Printf("400 requests over 1s, query=20ms, request timeout=500ms\n\n")
	run("case1_small_pool", good, func(db *sql.DB) {
		db.SetMaxOpenConns(2) // pool too small for the load
	})
	run("case2_leak", leaky, func(db *sql.DB) {
		db.SetMaxOpenConns(10)
	})
	run("case2b_leak_with_ctx", leakyCtx, func(db *sql.DB) {
		db.SetMaxOpenConns(10)
	})
	run("case3a_fixed_default_idle", good, func(db *sql.DB) {
		db.SetMaxOpenConns(20) // MaxIdleConns stays at the default (2)
	})
	run("case3b_fixed", good, func(db *sql.DB) {
		db.SetMaxOpenConns(20)
		db.SetMaxIdleConns(20)
		db.SetConnMaxLifetime(30 * time.Minute)
		db.SetConnMaxIdleTime(5 * time.Minute)
	})
}
```

Phần còn lại của file (gửi request, đọc `pg_stat_activity`, đo CPU) mình lược bớt cho ngắn. Đây là kết quả chạy trên máy local của mình:

```text
$ go run .
go1.27.3, PostgreSQL 17.11, pgx v5 stdlib
400 requests over 1s, query=20ms, request timeout=500ms

== case1_small_pool
requests=400 ok=166 timeout=234 other_err=0 elapsed=1.719s
latency(ok) p50=240ms p95=481ms p99=496ms
db.Stats: MaxOpen=2 Open=2 InUse=0 Idle=2 WaitCount=400 WaitDuration=2m35.331s MaxIdleClosed=0
postgres: max_connections=100 max_active_from_app=2 max_idle_in_tx=0 conns_opened=4 cpu=1% of one core
  t= 250ms InUse=2  Idle=0  WaitCount=77
  t= 500ms InUse=2  Idle=0  WaitCount=158
  t= 750ms InUse=2  Idle=0  WaitCount=238
  t=1000ms InUse=2  Idle=0  WaitCount=321
  t=1250ms InUse=2  Idle=0  WaitCount=399
  t=1500ms InUse=2  Idle=0  WaitCount=399

== case2_leak
requests=400 ok=139 timeout=261 other_err=0 elapsed=1.734s
latency(ok) p50=21ms p95=147ms p99=278ms
db.Stats: MaxOpen=10 Open=10 InUse=10 Idle=0 WaitCount=319 WaitDuration=3.073s MaxIdleClosed=1
postgres: max_connections=100 max_active_from_app=7 max_idle_in_tx=4 conns_opened=11 cpu=0% of one core
  t= 250ms InUse=10 Idle=0  WaitCount=4
  t= 500ms InUse=10 Idle=0  WaitCount=86
  t= 750ms InUse=10 Idle=0  WaitCount=165
  t=1000ms InUse=10 Idle=0  WaitCount=244
  t=1250ms InUse=10 Idle=0  WaitCount=319
  t=1500ms InUse=10 Idle=0  WaitCount=319

== case2b_leak_with_ctx
requests=400 ok=400 timeout=0 other_err=0 elapsed=1.224s
latency(ok) p50=20ms p95=21ms p99=23ms
db.Stats: MaxOpen=10 Open=2 InUse=0 Idle=2 WaitCount=0 WaitDuration=0s MaxIdleClosed=8
postgres: max_connections=100 max_active_from_app=8 max_idle_in_tx=1 conns_opened=20 cpu=1% of one core
  t= 250ms InUse=7  Idle=0  WaitCount=0
  t= 500ms InUse=6  Idle=1  WaitCount=0
  t= 750ms InUse=6  Idle=1  WaitCount=0
  t=1000ms InUse=7  Idle=1  WaitCount=0

== case3a_fixed_default_idle
requests=400 ok=400 timeout=0 other_err=0 elapsed=1.203s
latency(ok) p50=20ms p95=21ms p99=23ms
db.Stats: MaxOpen=20 Open=2 InUse=0 Idle=2 WaitCount=0 WaitDuration=0s MaxIdleClosed=6
postgres: max_connections=100 max_active_from_app=7 max_idle_in_tx=0 conns_opened=8 cpu=0% of one core
  t= 250ms InUse=7  Idle=1  WaitCount=0
  t= 500ms InUse=7  Idle=1  WaitCount=0
  t= 750ms InUse=7  Idle=1  WaitCount=0
  t=1000ms InUse=7  Idle=1  WaitCount=0

== case3b_fixed
requests=400 ok=400 timeout=0 other_err=0 elapsed=1.216s
latency(ok) p50=20ms p95=21ms p99=23ms
db.Stats: MaxOpen=20 Open=8 InUse=0 Idle=8 WaitCount=0 WaitDuration=0s MaxIdleClosed=0
postgres: max_connections=100 max_active_from_app=7 max_idle_in_tx=0 conns_opened=8 cpu=1% of one core
  t= 250ms InUse=7  Idle=1  WaitCount=0
  t= 500ms InUse=7  Idle=1  WaitCount=0
  t= 750ms InUse=7  Idle=1  WaitCount=0
  t=1000ms InUse=8  Idle=0  WaitCount=0
```

Ở ca đầu tiên (`case1_small_pool`), code viết đúng nhưng pool quá nhỏ, chỉ `SetMaxOpenConns(2)`, nên trong 400 request chỉ 166 request thành công, 234 request còn lại bị timeout. Query chỉ mất 20 ms, vậy mà latency của các request thành công đội lên: p50 là 240 ms, p95 là 481 ms, còn p99 chạm 496 ms, sát mức timeout 500 ms.

Nhìn vào `db.Stats()`, `WaitCount` (tổng số lần goroutine phải chờ kết nối) lên tới 400. `WaitDuration` là `2m35.331s`, lớn hơn nhiều so với thời gian chạy 1,719 giây, vì đây là thời gian chờ cộng dồn của mọi goroutine. Từ mốc 250 ms trở đi, pool đứng ở `InUse=2`, `Idle=0`, còn `WaitCount` tăng dần qua 77, 158, 238, 321 rồi 399. Trong lúc đó, PostgreSQL chỉ có tối đa 2 kết nối active trên trần 100 và CPU chỉ dùng 1% của một core.

## Pool cạn vì quên rows.Close() và transaction treo

Sang ca `case2_leak`, mình nâng lên `SetMaxOpenConns(10)` nhưng cố tình cài hai lỗi gây connection leak. Cứ 25 request thì có một request gọi `db.Query` không truyền context, rồi return sớm mà quên `rows.Close()`. Cứ 40 request thì có một request mở transaction bằng `BeginTx(context.Background(), nil)` rồi return luôn, không `Commit` cũng không `Rollback`. Kết quả: chỉ 139 request thành công, 261 request bị timeout.

Từ mốc 250 ms, `InUse` chạm 10, `Idle` về 0 và giữ nguyên như vậy tới cuối ca, kể cả khi không còn request nào chạy. `WaitCount` là 319, `WaitDuration` là 3,073 giây. Những request thành công là những request lấy được kết nối trước khi pool cạn, nên latency vẫn thấp: p50 là 21 ms, p95 là 147 ms, p99 là 278 ms. Số còn lại phải chờ cho tới khi hết 500 ms timeout.

![Pool cạn vì connection leak khiến request bị timeout dù database đang rảnh.](https://assets.200lab.io/sha256/54/54247cfe0c6d03bc0590d36605792cefeff1ed9d8a8438066703c8cd8f8e7d84/generations/0ff852deffe84f01725f7cce4e29ce9d284a01f6a59464c4c49f21faba70e31d)

Khung dưới đây so sánh ba lần chạy của demo. Bạn bấm chip "Pool 2 kết nối", "Có leak kết nối" hoặc "Đã chỉnh" để xem pool và số đo của từng ca, hoặc dùng nút Lùi / Tới để chuyển qua lại giữa ba ca.

Ở phía PostgreSQL, ca này ghi nhận tối đa 7 kết nối active, 4 kết nối `idle in transaction`, còn CPU là 0% của một core. Các kết nối bị leak cứ bị giữ mãi, cho tới khi chương trình gọi `pg_terminate_backend` để ngắt từ phía server. Chúng tích tụ dần, giống kiểu [memory leak trong Go](/blog/memory-leak-trong-go-cach-tim-va-khac-phuc) mà anh em backend thỉnh thoảng gặp.

Ở ca 2b (`case2b_leak_with_ctx`), mình giữ nguyên hai lỗi quên `Close()` và `Rollback()`, chỉ đổi sang `QueryContext` và `BeginTx` có truyền context của request (timeout 500 ms kèm `defer cancel()`). Lần này cả 400 request đều thành công, 0 timeout, `WaitCount=0` và cuối ca `InUse=0`. Theo tài liệu `database/sql`, khi context bị hủy, `Rows` từ `QueryContext` sẽ tự đóng và transaction từ `BeginTx` sẽ tự rollback. Dù vậy, đây không phải cách sửa: bạn vẫn phải gọi `Close` và `Rollback`. Ca này chỉ để giải thích vì sao lỗi leak hay bùng lên khi quên truyền context.

## Chỉnh SetMaxOpenConns và SetMaxIdleConns theo tải thật

Ở ca 3a (`case3a_fixed_default_idle`), code đã có `defer rows.Close()`, truyền context và đặt `SetMaxOpenConns(20)` nhưng giữ `MaxIdleConns` mặc định bằng 2. Cả 400 request đều thành công (p50 20 ms, p95 21 ms, p99 23 ms, `WaitCount=0`). Nhưng cuối ca, `db.Stats()` báo `Open=2`, `Idle=2` và `MaxIdleClosed=6`: pool chỉ giữ lại 2 kết nối rảnh và phải đóng bỏ 6 kết nối vừa mở.

Sang ca 3b (`case3b_fixed`), mình đặt `SetMaxOpenConns(20)`, `SetMaxIdleConns(20)`, kèm `SetConnMaxLifetime(30*time.Minute)` và `SetConnMaxIdleTime(5*time.Minute)`. Cả 400 request đều thành công, p99 là 23 ms, `WaitCount=0`, `WaitDuration=0s`, và cuối ca `MaxIdleClosed=0`, `Open=8`, `Idle=8`. Hai mức 30 phút và 5 phút chỉ là giá trị mình chọn cho đủ cấu hình. Ca này chỉ chạy khoảng 1,2 giây nên demo không đo được tác dụng của hai tham số này.

Trong timeline của ca 3b, số kết nối `InUse` chỉ dao động từ 7 đến 8 dù trần là 20. Muốn nhẩm nhanh cần bao nhiêu kết nối cùng lúc, bạn có thể ước lượng thô (chỉ để tham khảo, không phải công thức chuẩn): lấy số request mỗi giây nhân thời gian chạy trung bình của một query. Ở đây, 400 request/giây nhân 0,02 giây ra 8 kết nối, khớp với mức `InUse` 7 đến 8 đo được, nên `MaxOpenConns=20` là mức trần có dư để dự phòng.

Ngoài thực tế, mình thường lấy số core CPU của server database nhân 2 làm điểm xuất phát khi đặt số connection tới PostgreSQL. Đây chỉ là thói quen riêng của mình chứ không phải quy tắc chung, nên bạn vẫn cần kiểm lại bằng các số đo như `WaitCount`. Bạn cũng cần lưu ý con số này là tổng kết nối cho cả cụm service.

![Ước lượng thô số kết nối từ tải và kiểm lại tổng kết nối của mọi instance với max_connections.](https://assets.200lab.io/sha256/a8/a83ef72ef8554e42e9e5e600772df4799fe95e0ad46991b874742b4e4099a671/generations/f82b5eb56c136d8e7fbb91bbb8a963da15db2cf28f6f2706bb7199b92b7519bf)

Đặt `MaxOpenConns` quá cao cũng có thể gây chuyện khi hệ thống chạy theo [kiến trúc microservices](/blog/microservices-la-gi) với nhiều instance, vì tổng `MaxOpenConns` của mọi instance cộng lại phải thấp hơn `max_connections` của PostgreSQL. Chẳng hạn bạn chạy 5 instance, mỗi instance `MaxOpenConns=20`, thì tổng số kết nối có thể mở là 5 × 20 = 100, chạm đúng giới hạn mặc định 100 của database.

## Đọc db.Stats và pg_stat_activity để bắt lỗi pool

Khi chạy thật, bạn nên đọc `db.Stats()` mỗi 10 đến 15 giây rồi ghi log hoặc đẩy lên hệ thống metrics:

```go
stats := db.Stats()
log.Printf("open=%d in_use=%d idle=%d wait_count=%d wait_dur=%s max_idle_closed=%d",
    stats.OpenConnections, stats.InUse, stats.Idle,
    stats.WaitCount, stats.WaitDuration, stats.MaxIdleClosed)
```

`WaitCount` và `WaitDuration` tăng vọt nghĩa là request đang phải xếp hàng chờ kết nối. Một dấu hiệu khác: `InUse` chạm trần `MaxOpenConns`, `Idle` bằng 0 và cứ giữ như vậy cả khi tải đã giảm. Trường hợp này thường là do connection leak.

Trong demo trên máy mình, triệu chứng đầu tiên khi pool cạn là request timeout hàng loạt: 234/400 ở ca pool 2 kết nối, 261/400 ở ca leak kết nối, trong khi CPU của PostgreSQL chỉ ở mức 1% và 0% của một core. `WaitCount` tăng đều qua từng mốc đo. Riêng ca leak kết nối, `InUse` đứng yên ở 10 (bằng `MaxOpenConns`) với `Idle=0`, còn phía PostgreSQL có 4 kết nối nằm ở trạng thái `idle in transaction`.

Muốn kiểm tra chéo từ phía PostgreSQL, bạn có thể thêm `application_name` vào DSN của từng service rồi query view `pg_stat_activity`:

```sql
SELECT state, count(*)
FROM pg_stat_activity
WHERE application_name = 'order-service'
GROUP BY state;
```

Cột `state` cho biết kết nối đang `active`, `idle` hay `idle in transaction`. Thấy nhiều kết nối `idle in transaction` thì thường là code đã mở [transaction trong database](/blog/transaction-isolation-level-la-gi) mà chưa `Commit` hoặc `Rollback`. Bạn có thể bật thêm `idle_in_transaction_session_timeout` để PostgreSQL tự ngắt các session nằm `idle in transaction` quá lâu (theo [tài liệu cấu hình client của PostgreSQL 17](https://www.postgresql.org/docs/17/runtime-config-client.html), tham số này mặc định là 0, tức đang tắt).

Pool cạn còn dễ gây hiệu ứng dây chuyền: request timeout, client dùng [cơ chế retry](/blog/retry-la-gi) gọi lại ngay lập tức, query dồn xuống càng nhiều thì pool càng nghẽn nặng. Lúc này, đặt [mẫu thiết kế circuit breaker](/blog/circuit-breaker-la-gi) ở phía gọi giúp ngắt mạch sớm để service kịp hồi phục. Bạn cũng nên phòng [cache stampede](/blog/cache-stampede-la-gi), tức lúc cache hết hạn đồng loạt và nhiều query cùng đổ xuống chiếm hết pool.

## Sai lầm hay gặp với connection pool trong Go

Sai lầm đầu tiên là tưởng `sql.Open` chỉ mở một kết nối, nên gọi `sql.Open` rồi `db.Close()` ngay trong từng request handler. Làm vậy thì pool không dùng lại được kết nối nào, còn PostgreSQL phải tạo process mới liên tục. Bạn chỉ nên tạo một `*sql.DB` duy nhất lúc app khởi động.

Sai lầm thứ hai là return sớm mà quên `rows.Close()`, hoặc mở transaction nhưng khi gặp lỗi lại thoát hàm mà quên `Rollback`. Theo tài liệu `database/sql`, `Rows` chỉ tự đóng khi `rows.Next()` đọc hết và trả về `false` (nếu chỉ lấy một dòng, hãy dùng `QueryRowContext(...).Scan(...)`). Với transaction, cách viết quen thuộc là đặt `defer tx.Rollback()` ngay sau `BeginTx`. Nếu đã `Commit()` rồi thì `Rollback()` chỉ trả về `sql.ErrTxDone`, không ảnh hưởng gì tới transaction đã commit:

```go
tx, err := db.BeginTx(ctx, nil)
if err != nil {
    return err
}
defer tx.Rollback()
```

Nhóm sai lầm thứ ba gồm hai kiểu. Kiểu đầu là gọi `db.Query`, `db.Exec` không kèm context, nên request đã quá hạn mà kết nối vẫn không được thu hồi. Kiểu sau là để nguyên cấu hình mặc định của thư viện. Suy từ tài liệu (demo không chạy ca này), để `MaxOpenConns` ở mặc định 0, tức không giới hạn, thì khi tải tăng service có thể mở kết nối tràn lan tới mức chạm `max_connections` của PostgreSQL. Còn nếu chỉ tăng `MaxOpenConns` mà quên nâng `MaxIdleConns` khỏi mức 2 như ca 3a, pool sẽ phải đóng mở kết nối liên tục.

Chỉ vài dòng code mà demo đã tái hiện đủ ba lỗi hay gặp làm pool 10 kết nối cạn ngay từ mốc 250 ms: return sớm quên `rows.Close()`, mở transaction mà thiếu `Commit` hay `Rollback`, và gọi query không truyền context của request. Ca `case2b_leak_with_ctx` cho thấy truyền context giúp kéo kết nối về khi request hết hạn. Vì vậy, một cách rà soát nhanh là tìm các chỗ gọi `Query` hay `BeginTx` và xem đã có đủ context, `defer rows.Close()` và `defer tx.Rollback()` chưa.

Tóm lại, mình đặt `SetMaxOpenConns` theo phép ước lượng thô (số request/giây nhân thời gian query, cộng thêm khoảng dự phòng), miễn là tổng kết nối của mọi instance vẫn nằm dưới `max_connections` của PostgreSQL. Khi cần giữ kết nối qua đợt cao điểm rồi tự nhả lúc vắng tải, mình đặt `SetMaxIdleConns` bằng `SetMaxOpenConns` kèm `SetConnMaxIdleTime`. Trong code, đừng quên `defer rows.Close()`, `defer tx.Rollback()` và truyền context ở mọi câu query. Cuối cùng, mình đưa `WaitCount` và `WaitDuration` lên dashboard để phát hiện nghẽn pool sớm, vì các con số trong bài chỉ lấy từ demo chạy trên máy local với `pg_sleep`, chưa phải tải production.

## Đọc thêm

- [Goroutines là gì](/blog/goroutines-la-gi): hiểu goroutine, thứ demo dùng để gửi 400 request cùng lúc vào một pool.
- [Transaction và isolation level](/blog/transaction-isolation-level-la-gi): nắm rõ vòng đời một transaction để tránh giữ kết nối quá lâu ở trạng thái `idle in transaction`.
- [Retry với backoff và jitter: gọi lại API lỗi mà không làm sập server](/blog/retry-la-gi): cách cấu hình gọi lại hợp lý từ phía client để không dồn thêm tải khi connection pool đang cạn.
- [Cache stampede: cache hết hạn, hàng loạt request dồn xuống database](/blog/cache-stampede-la-gi): khi cache hết hạn đồng loạt, nhiều query cùng dồn xuống database và tranh nhau kết nối trong pool.

## Đọc thêm

- [Outbox pattern: ghi database và gửi message mà không mất đơn](https://200lab.io/blog/outbox-pattern-la-gi.md): Outbox pattern là gì: ghi đơn và event trong cùng một transaction, rồi relay gửi sau; demo PostgreSQL cho thấy dual-write làm mất message khi service restart.
- [Retry với backoff và jitter: gọi lại API lỗi mà không làm sập server](https://200lab.io/blog/retry-la-gi.md): Retry là gì: gọi lại khi lỗi tạm dễ thành thundering herd; exponential backoff chưa đủ, cần jitter để lệch nhịp và đo đỉnh request theo giây.
- [Distributed lock là gì, vì sao lock Redis vẫn để dữ liệu bị ghi đè](https://200lab.io/blog/distributed-lock-la-gi.md): Distributed lock giúp nhiều instance không chạy trùng một việc. Redis SET NX chặn được chạy cùng lúc, nhưng lock hết hạn giữa chừng thì cần thêm fencing token.
- [Rate limiting là gì? So sánh Fixed Window, Sliding Window, Token Bucket](https://200lab.io/blog/rate-limiting-la-gi.md): Rate limiting kiểm soát tần suất request và trả về mã HTTP 429 khi vượt ngưỡng. Xem so sánh 3 thuật toán cùng cách chọn key và đặt limiter.
- [CRDT là gì? Cách đồng bộ dữ liệu khi nhiều người cùng sửa](https://200lab.io/blog/crdt-la-gi.md): CRDT giúp đồng bộ dữ liệu khi nhiều người cùng chỉnh sửa lúc mất mạng. Các thay đổi được kết hợp ra sao, và xung đột được xử lý thế nào?
- [Mọi bài viết chủ đề Backend](https://200lab.io/blog/tags/backend.md)

Toàn bộ nội dung: https://200lab.io/llms.txt
