Nhiều sự cố “DB chậm” ở ứng dụng Spring thật ra là chờ connection: pool cạn vì connection bị giữ quá lâu, hoặc quá nhiều instance cùng mở connection tới một database. Bài này giải thích HikariCP cấp connection thế nào, đặt từng tham số theo lý do của nó, và chọn kích thước pool bằng con số. Thí nghiệm chạy trên JDK 21.0.13, HikariCP 7.0.2, H2 2.3.232; mặc định trích từ source HikariCP 7.0.2.
1. Vì sao cần connection pool
Ý chính: tạo một connection DB đắt, dùng nó thì rẻ. Pool mở sẵn vài connection, cho mượn rồi nhận lại, nên mỗi request chỉ trả phần rẻ.
Một connection PostgreSQL mới phải đi qua:
- TCP 1 RTT, TLS thêm 1 RTT và CPU (xem mạng máy tính cho backend).
- Xác thực SCRAM-SHA-256: thêm vài lượt trao đổi.
- Backend process: postmaster fork một process cho mỗi connection, tốn vài MB bộ nhớ (ước lượng). Vì thế
max_connectionsmặc định chỉ 100.
Đo trên máy mình với H2 chạy TCP server trên loopback (không TLS, không fork):
| Cách làm | Thời gian mỗi lần (200 lần) |
|---|---|
Mở connection mới + SELECT 1 + đóng |
1,09–1,18 ms |
Mượn từ HikariCP + SELECT 1 + trả |
0,042–0,048 ms |
Chênh khoảng 25 lần ngay trên loopback. PostgreSQL qua mạng có TLS còn chênh hơn, nhưng mình chưa đo.
2. HikariCP bên trong: getConnection chờ thế nào
Ý chính: HikariCP giữ connection trong một ConcurrentBag. Lấy connection là thử nhanh không khoá, hết thì xếp hàng chờ người khác trả, có hạn chót.
flowchart TD
A[getConnection] --> B{Danh sách thread-local<br/>có connection rảnh?}
B -- có, CAS thành công --> R[Kiểm tra còn sống nếu rảnh hơn 500 ms]
B -- không --> C{Quét danh sách chung<br/>có connection rảnh?}
C -- có --> R
C -- không --> D[Báo cần thêm connection<br/>nếu total nhỏ hơn max]
D --> E[Chờ trên SynchronousQueue<br/>tối đa connectionTimeout]
E -- có người trả hoặc connection mới --> R
E -- hết giờ --> X[SQLTransientConnectionException]
R --> OK[Trả proxy connection cho ứng dụng]
- Thread-local list: mỗi thread thử trước các connection nó vừa dùng; thường trúng, không tranh chấp.
- CAS (compare-and-set): đổi trạng thái
NOT_IN_USE → IN_USEbằng một lệnh nguyên tử, không lock. - Handoff: trả connection khi có người chờ thì HikariCP đưa thẳng qua
SynchronousQueuecông bằng (ai chờ trước nhận trước). - Kiểm tra sống: connection rảnh quá 500 ms được kiểm bằng
isValid(); chết thì đóng và lấy cái khác trong thời gian còn lại.
Pool cạn trong thí nghiệm (pool 2 connection, cả hai đang bị giữ, connectionTimeout=500):
SQLTransientConnectionException after 512 ms
E1 - Connection is not available, request timed out after 505ms (total=2, active=2, idle=0, waiting=0)
Năm lần chạy cho 512–522 ms. active=2 bằng total=2: mọi connection đang bị mượn. Câu hỏi tiếp theo luôn là “ai đang giữ, giữ bao lâu”.
Đoạn borrow của ConcurrentBag trong HikariCP 7.0.2
public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException {
// 1. thử connection thread này vừa dùng (threadLocalList), CAS NOT_IN_USE -> IN_USE
// 2. quét sharedList, CAS từng cái
final var waiting = waiters.incrementAndGet();
try {
listener.addBagItem(waiting); // 3. xin tạo thêm (nếu chưa tới max)
timeout = timeUnit.toNanos(timeout);
do { // 4. chờ người khác trả
final var start = currentTime();
final T bagEntry = handoffQueue.poll(timeout, NANOSECONDS);
if (bagEntry == null || bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) return bagEntry;
timeout -= elapsedNanos(start);
} while (timeout > 10_000);
return null; // hết giờ -> pool ném exception
} finally {
waiters.decrementAndGet();
}
}
(Rút gọn bước 1–2.) Tạo connection mới chạy trên một executor riêng, không phải trên thread đang chờ, nên một DB chậm kết nối không làm connectionTimeout bị vượt.
Chú ý kiểm tra sống: nếu connection đã “chết lặng” sau NAT, isValid() có thể chờ tới validationTimeout (mặc định 5 giây) mới kết luận. Đó là lý do nên để maxLifetime thay connection trước khi thiết bị giữa đường quên nó.
3. Các tham số quan trọng
Ý chính: các tham số trả lời ba câu: chờ connection bao lâu, connection sống bao lâu, và ai giữ quá lâu.
Tham số (Spring: spring.datasource.hikari.*) |
Mặc định 7.0.2 | Ý nghĩa và cách đặt |
|---|---|---|
maximumPoolSize |
10 | Trần số connection. Chọn theo mục 4 |
minimumIdle |
bằng maximumPoolSize |
Nên giữ nguyên: pool cố định, không phải tạo connection lúc tải vọt lên |
connectionTimeout |
30 s (tối thiểu 250 ms) | Chờ mượn tối đa bao lâu. Đặt ngắn hơn timeout của request (ví dụ 1–3 s) để lỗi nhanh |
idleTimeout |
10 phút | Chỉ có tác dụng khi minimumIdle < maximumPoolSize |
maxLifetime |
30 phút (tối thiểu 30 s) | Tuổi tối đa; trừ ngẫu nhiên tới 25% để connection không cùng hết tuổi |
keepaliveTime |
2 phút (tối thiểu 30 s, nhỏ hơn maxLifetime) |
Định kỳ “chạm” connection rảnh để DB và thiết bị mạng không đóng nó |
leakDetectionThreshold |
0 = tắt (tối thiểu 2 s) | Log stack trace nơi mượn quá ngưỡng mà chưa trả |
validationTimeout |
5 s | Thời gian tối đa kiểm tra connection còn sống |
Leak detection: log thật khi giữ connection quá ngưỡng
4. Chọn kích thước pool
Ý chính: pool chỉ cần đủ cho số connection đang bận cùng lúc. DB chỉ chạy song song được chừng ấy việc theo số core và đĩa; pool to hơn chỉ dời hàng đợi vào trong DB.
Ba con số để chọn:
- Điểm khởi đầu (wiki “About Pool Sizing” của HikariCP, gốc từ PostgreSQL):
(số core của DB × 2) + số đĩa hiệu dụng. DB 8 core, SSD: khoảng 17 connection tổng, không phải mỗi instance. - Little’s Law (số việc trong hệ thống = tốc độ đến × thời gian ở lại, xem ước lượng back-of-the-envelope): 2.000 transaction/giây × 5 ms giữ = trung bình 10 connection bận.
- Trần của DB: số instance ×
maximumPoolSize+ job, migration, admin <max_connections. 20 pod × 10 = 200 đã vượt mặc định 100 của PostgreSQL.
Thí nghiệm khớp Little’s Law: pool 10, 200 task mỗi task giữ connection khoảng 55 ms. Trần 10 / 0,055 s ≈ 180 task/giây, nên 200 task cần khoảng 1,1 giây; đo được 1.112–1.167 ms.
5. PgBouncer transaction pooling và các bẫy
Ý chính: PgBouncer là pool đứng giữa các ứng dụng và PostgreSQL. Ở chế độ transaction, connection thật chỉ thuộc về client trong một transaction, nên hàng nghìn connection phía app dùng chung vài chục connection tới DB. Đổi lại, mọi thứ gắn với session không còn tin được.
| Chế độ | Connection thật thuộc về client trong | Dùng khi |
|---|---|---|
session |
Cả phiên | Cần đủ tính năng session |
transaction |
Một transaction | Nhiều instance, transaction ngắn: phổ biến nhất |
statement |
Một câu lệnh | Hiếm; cấm transaction nhiều câu |
Transaction sau có thể chạy trên connection khác, nên những thứ sau hỏng:
SETcấp session (search_path,timezone,statement_timeout): dùngSET LOCALbên trong transaction.- Advisory lock cấp session,
LISTEN/NOTIFY, bảng tạm sống qua transaction, cursorWITH HOLD. - Prepared statement phía server: pgjdbc chuyển sang named prepared statement sau
prepareThreshold(mặc định 5) lần chạy, transaction sau ở connection khác gặp lỗi kiểuprepared statement "S_1" does not exist.
6. @Transactional giữ connection khi gọi ra ngoài
Ý chính: Spring lấy connection lúc bắt đầu transaction và chỉ trả khi commit hoặc rollback. Mọi thứ chạy bên trong, kể cả gọi HTTP, đều cộng vào thời gian giữ connection.
@Transactional
public void pay(long orderId) {
Order o = orders.findById(orderId).orElseThrow();
PaymentResult r = gateway.charge(o); // HTTP 50 ms–30 s, connection vẫn bị giữ
o.markPaid(r.reference());
}
Thí nghiệm (5 lần chạy): 200 task trên virtual thread, pool 10, mỗi task chạy SELECT 1 và một “lời gọi ngoài” 50 ms.
| Lời gọi 50 ms nằm ở đâu | connectionTimeout |
Thành công / lỗi | Tổng thời gian | Thread chờ nhiều nhất |
|---|---|---|---|---|
| Trong lúc giữ connection | 30 s | 200 / 0 | 1.112–1.167 ms | 192 |
| Trong lúc giữ connection | 500 ms | 98 / 102 | 524–557 ms | 192–193 |
| Trước khi mượn connection | 30 s | 200 / 0 | 54–62 ms | 0–1 |
| Trước khi mượn connection | 500 ms | 200 / 0 | 55–63 ms | 0–2 |
Cùng lượng việc, dời lời gọi ra khỏi phần giữ connection nhanh hơn khoảng 20 lần và hết lỗi. Cách sửa: gọi ngoài trước, rồi mở transaction ngắn để ghi (TransactionTemplate, hoặc tách bean để proxy @Transactional có tác dụng). Cần hai bước nhất quán thì dùng trạng thái trung gian, idempotency key hoặc outbox, xem distributed transaction, saga và outbox.
7. Virtual thread và pool
Ý chính: virtual thread làm thread gần như miễn phí, nên trần không còn là 200 thread Tomcat mà là số connection. Pool thành chốt chặn (back-pressure) chính, và connectionTimeout quyết định quá tải thành chờ hay thành lỗi.
- Đừng tăng
maximumPoolSizetheo số virtual thread; số connection vẫn tính theo Little’s Law. connectionTimeoutngắn biến quá tải thành lỗi nhanh (bảng trên: 102 lỗi sau khoảng 500 ms) thay vì hàng nghìn request treo 30 giây.- Pinning: trên JDK 21–23, virtual thread chờ I/O trong
synchronizedghim carrier thread; driver cũ dùngsynchronizedquanh I/O có thể làm cạn carrier. JDK 24 (JEP 491) gỡ hạn chế này.
Thread pool, virtual thread và Semaphore chi tiết ở ExecutorService và virtual thread; tầng epoll bên dưới ở I/O model và epoll.
8. Pool của HTTP client và thread pool
Ý chính: HTTP client cũng có pool với giới hạn mặc định riêng, thường nhỏ hơn bạn nghĩ. Gọi nhiều tới một host thì giới hạn theo route (theo host) mới là trần.
| Client (phiên bản đã kiểm) | Mặc định | Ghi chú |
|---|---|---|
Apache HttpClient 5 (PoolingHttpClientConnectionManager, 5.5.1) |
Tổng 25, mỗi route 5 | Request thứ 6 tới cùng host chờ lease; đặt connectionRequestTimeout |
OkHttp (ConnectionPool, 4.12.0) |
Giữ tối đa 5 connection rảnh, 5 phút | Số request đồng thời giới hạn bởi Dispatcher |
JDK HttpClient (JDK 21) |
Pool HTTP/1.1 không giới hạn, connection rảnh giữ 30 giây | HTTP/2 ghép mọi request lên một connection mỗi host |
Tomcat 200 thread với Hikari 10 connection: DB chậm thì tới 190 thread đứng chờ, ổn nếu connectionTimeout ngắn, nguy hiểm nếu là 30 giây. Tạo HTTP client một lần rồi dùng chung (web và HTTP); timeout và bulkhead ở Timeout, retry và circuit breaker.
9. Metric cần theo dõi
Ý chính: ba câu hỏi: có ai chờ connection không, giữ bao lâu, có timeout không. HikariCP đẩy sẵn qua Micrometer (Prometheus đổi dấu chấm thành gạch dưới).
| Metric | Ý nghĩa | Cảnh báo khi |
|---|---|---|
hikaricp.connections.pending |
Số thread đang chờ connection | Lớn hơn 0 kéo dài vài phút |
hikaricp.connections.active / .idle / .max |
Đang mượn, đang rảnh, trần | active dính sát max |
hikaricp.connections.acquire |
Thời gian chờ để mượn | p99 tăng: pool hoặc DB nghẽn |
hikaricp.connections.usage |
Thời gian giữ connection | p99 tăng: transaction dài, gọi ngoài trong transaction |
hikaricp.connections.timeout |
Số lần mượn thất bại | Bất kỳ giá trị nào lớn hơn 0 |
hikaricp.connections.creation |
Thời gian tạo connection | Tạo quá thường: maxLifetime quá ngắn hoặc DB cắt connection |
usage hay bị bỏ qua nhất, dù theo Little’s Law nó cùng throughput quyết định số connection bận: usage p99 tăng báo pool sắp cạn trước cả pending.
Bài tập
Bài 1: Tái hiện pool cạn và connectionTimeout
Viết chương trình JDK 21 với HikariCP và H2: (a) pool 2, giữ cả hai connection rồi mượn cái thứ ba với connectionTimeout=500, đọc thông báo lỗi; (b) pool 10, 200 virtual thread, so sánh gọi ngoài 50 ms “trong lúc giữ connection” với “trước khi mượn”.
Lời giải bài 1: code và kết quả
Classpath: HikariCP-7.0.2.jar, h2-2.3.232.jar, slf4j-api-1.7.36.jar, slf4j-simple-1.7.36.jar. Biên dịch bằng javac -cp $CP PoolLab.java, chạy java -cp $CP:. PoolLab.
import com.zaxxer.hikari.*;
import java.sql.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
public class PoolLab {
static HikariDataSource pool(String name, int size, long timeoutMs) {
HikariConfig c = new HikariConfig();
c.setPoolName(name);
c.setJdbcUrl("jdbc:h2:mem:lab;DB_CLOSE_DELAY=-1");
c.setUsername("sa");
c.setMaximumPoolSize(size);
c.setConnectionTimeout(timeoutMs);
return new HikariDataSource(c);
}
public static void main(String[] args) throws Exception {
// (a) lược bớt: pool("E1", 2, 500), hai thread giữ connection 3 s, thread chính gọi getConnection()
// rồi in tên exception, thời gian chờ và e.getMessage()
// (b) giữ connection trong lúc gọi ngoài hay không
for (boolean hold : new boolean[]{true, false}) for (long timeout : new long[]{30_000, 500}) {
try (HikariDataSource ds = pool("E2", 10, timeout)) {
ds.getConnection().close(); Thread.sleep(300); // khởi động, cho pool đầy 10
AtomicInteger ok = new AtomicInteger(), failed = new AtomicInteger(), maxPending = new AtomicInteger();
HikariPoolMXBean mx = ds.getHikariPoolMXBean();
ScheduledExecutorService sampler = Executors.newSingleThreadScheduledExecutor();
sampler.scheduleAtFixedRate(() -> maxPending.accumulateAndGet(mx.getThreadsAwaitingConnection(), Math::max), 0, 5, TimeUnit.MILLISECONDS);
long t = System.nanoTime();
try (ExecutorService ex = Executors.newVirtualThreadPerTaskExecutor()) {
for (int i = 0; i < 200; i++) ex.submit(() -> {
try {
if (!hold) Thread.sleep(50); // gọi ngoài trước khi mượn
try (Connection c = ds.getConnection(); Statement st = c.createStatement()) {
st.executeQuery("SELECT 1").close();
if (hold) Thread.sleep(50); // gọi ngoài khi đang giữ
}
ok.incrementAndGet();
} catch (SQLException e) { failed.incrementAndGet(); }
catch (InterruptedException e) { Thread.currentThread().interrupt(); }
});
}
sampler.shutdownNow();
System.out.printf("hold=%-5s timeout=%5d: ok=%3d failed=%3d wall=%4.0f ms maxPending=%d%n",
hold, timeout, ok.get(), failed.get(), (System.nanoTime() - t) / 1e6, maxPending.get());
}
}
}
}
Một lần chạy (các lần khác nằm trong khoảng đã ghi ở mục 2 và 6):
SQLTransientConnectionException after 512 ms
E1 - Connection is not available, request timed out after 505ms (total=2, active=2, idle=0, waiting=0)
hold=true timeout=30000: ok=200 failed= 0 wall=1112 ms maxPending=192
hold=true timeout= 500: ok= 98 failed=102 wall= 524 ms maxPending=192
hold=false timeout=30000: ok=200 failed= 0 wall= 54 ms maxPending=0
hold=false timeout= 500: ok=200 failed= 0 wall= 55 ms maxPending=0
Đọc kết quả:
- (a) Lỗi đến sau khoảng
connectionTimeoutcộng vài ms;waiting=0vì thread vừa hết giờ đã rời hàng chờ. - (b) Khi giữ connection, 10 connection phục vụ lần lượt khoảng 20 lượt × 55 ms ≈ 1,1 s, đúng Little’s Law. Với timeout 500 ms, chỉ những task được phục vụ trong khoảng 9–10 lượt đầu thành công (98), còn lại lỗi. Khi gọi ngoài trước, 200 virtual thread ngủ song song 50 ms rồi mỗi task chỉ giữ connection vài chục micro giây, không ai phải chờ.
Chưa chạy: PostgreSQL thật qua mạng có TLS, PgBouncer (Docker không chạy trên máy này).
Bài 2: Chọn kích thước pool cho một hệ thống
Service chạy 6 instance, autoscale tối đa 12. PostgreSQL 8 core, SSD, max_connections = 200. Cao điểm 3.000 transaction/giây toàn hệ thống, mỗi transaction giữ connection trung bình 8 ms, p99 30 ms. Job batch cần 10 connection, chừa 10 cho admin, migration. Chọn maximumPoolSize và connectionTimeout.
Lời giải bài 2
- Little’s Law, trung bình: 3.000 × 0,008 = 24 connection bận trên toàn hệ thống.
- Lúc chậm: nếu nhiều transaction cùng chạm p99, 3.000 × 0,03 = 90. Đây là trần khi DB đã chậm; cấp đủ 90 connection chỉ làm DB chậm thêm.
- Công thức: 8 × 2 + 1 = 17 connection làm việc hiệu quả cùng lúc. 24 đã vượt một chút: DB gần bão hoà lúc cao điểm, nên giảm thời gian giữ (8 ms khá dài cho OLTP) trước khi nghĩ tới pool to hơn.
- Chia cho instance: lúc 12 instance (trường hợp xấu nhất về số connection), 24 / 12 = 2 bận mỗi instance; lúc 6 instance là 4. Chọn
maximumPoolSize = 6: đủ cho 4 bận trung bình cộng biên độ khi 6 instance, và khi 12 instance là 72 connection. - Kiểm tra trần: 12 × 6 + 10 (batch) + 10 (admin) = 92 < 200. Còn dư để deploy kiểu rolling (instance cũ và mới cùng sống) mà không chạm
max_connections. connectionTimeout: API cam kết p99 ≤ 1 giây thì đặt khoảng 500 ms–1 s: hết connection là lỗi nhanh, trả 503 để client retry, thay vì giữ thread 30 giây.- Theo dõi:
pendingvàusagep99 khi tải thử.pendingcao mà CPU DB còn rảnh thì tăng lên 8; CPU DB đã cao thì không tăng mà tối ưu query.
Nếu sau này cần 50 instance, 50 × 6 = 300 vượt trần: đặt PgBouncer transaction mode trước PostgreSQL thay vì hạ pool xuống 2–3.
Ghi nhớ
- Kể được các bước tốn kém khi mở một connection PostgreSQL và vì sao pool nhanh hơn.
- Đặt được
maxLifetime,keepaliveTime,connectionTimeouttheo timeout của DB và mạng. - Tính được kích thước pool bằng công thức và Little’s Law, có kiểm tra số instance × pool so với
max_connections. - Biết các bẫy của PgBouncer transaction mode,
@Transactionalgọi ra ngoài và open-in-view.
Câu hỏi phỏng vấn
Junior
Vì sao ứng dụng cần connection pool?
Vì mở một connection DB đắt (TCP, TLS, xác thực, process ở server), còn dùng lại connection có sẵn gần như miễn phí.
Pool cũng giới hạn số connection tới DB, để tải tăng thì ứng dụng xếp hàng chứ không làm sập database. Đo trên loopback với H2: mở mới khoảng 1,1 ms, mượn từ pool khoảng 0,045 ms.
Ứng dụng báo “Connection is not available, request timed out after 30000ms”. Nghĩa là gì?
Pool đã hết connection rảnh và thread chờ hết connectionTimeout (30 giây mặc định) mà không ai trả.
Xem active so với total trong thông báo, rồi tìm chỗ giữ connection lâu: transaction dài, gọi ngoài trong transaction, connection leak, hoặc DB chậm.
Mid
maxLifetime và keepaliveTime dùng để làm gì?
maxLifetime thay connection trước khi DB hay thiết bị mạng đóng nó; keepaliveTime định kỳ chạm connection rảnh để nó không bị coi là rảnh.
maxLifetime phải ngắn hơn vài giây so với mọi giới hạn trên đường đi (MySQL wait_timeout, firewall, NAT). HikariCP trừ ngẫu nhiên tới 25% để connection không cùng hết tuổi.
Vì sao gọi HTTP bên trong @Transactional là nguy hiểm?
Connection bị giữ suốt lời gọi HTTP, nên thời gian giữ connection tăng theo latency của bên kia và pool cạn rất nhanh.
Thí nghiệm: thêm 50 ms giữ connection làm 200 task chậm từ 55 ms lên 1.100 ms; với timeout 500 ms thì một nửa lỗi. Gọi ngoài trước rồi mở transaction ngắn để ghi.
PgBouncer transaction mode làm hỏng những gì?
Mọi thứ gắn với session: SET cấp session, advisory lock session, LISTEN/NOTIFY, bảng tạm, cursor WITH HOLD, và prepared statement phía server nếu không cấu hình.
Dùng SET LOCAL, PgBouncer 1.21+ với max_prepared_statements, hoặc prepareThreshold=0 ở pgjdbc.
Senior
Bạn chọn kích thước connection pool thế nào?
Bắt đầu từ Little’s Law (throughput × thời gian giữ) và công thức (core × 2) + đĩa của DB, rồi chia cho số instance và kiểm tra tổng nhỏ hơn max_connections.
Sau đó tải thử, theo dõi pending, usage và CPU của DB. Chỉ tăng khi có người chờ và DB còn dư; nếu DB đã bão hoà, giảm thời gian giữ connection. Quá nhiều instance thì dùng PgBouncer.
Chuyển sang virtual thread thì cấu hình pool có cần đổi không?
Kích thước pool không cần tăng, nhưng connectionTimeout phải ngắn và có giới hạn đồng thời rõ ràng, vì pool trở thành chốt chặn chính.
Trước đây 200 thread Tomcat giới hạn số người chờ; với virtual thread có thể có hàng nghìn người chờ connection. Trên JDK 21–23 còn phải để ý pinning khi driver dùng synchronized quanh I/O.
Sau sự cố DB chậm, pool không tự hồi phục: pending vẫn cao dù DB đã ổn. Bạn nghĩ tới gì?
Hàng đợi tồn đọng và retry đang giữ tải cao, hoặc connection đã chết lặng sau NAT và bị kiểm tra chậm, hoặc leak đang giữ connection.
Xem usage p99 (giữ lâu bất thường), timeout, log leak detection, pg_stat_activity (idle in transaction). Giảm retry, connectionTimeout ngắn để xả hàng đợi, và maxLifetime ngắn hơn timeout mạng để connection chết bị thay.
Từ vựng tiếng Anh
| Term | Phát âm | Nghĩa | Ví dụ câu tiếng Anh dùng trong phỏng vấn |
|---|---|---|---|
| connection pool | /kəˈnek.ʃən puːl/ | bể connection dùng lại | “The pool pays the handshake cost once and lends connections out.” |
| pool exhaustion | /puːl ɪɡˈzɑːs.tʃən/ | pool cạn | “Pool exhaustion showed up as connection timeouts, not as slow queries.” |
| hold time | /hoʊld taɪm/ | thời gian giữ | “Hold time, not pool size, decided our throughput.” |
| connection leak | /kəˈnek.ʃən liːk/ | rò connection | “Leak detection pointed at a code path that never closed the connection.” |
| back-pressure | /bæk ˈpreʃ.ɚ/ | chặn bớt khi quá tải | “With virtual threads, the pool is the back-pressure point.” |
| transaction pooling | /trænˈzæk.ʃən ˈpuː.lɪŋ/ | gộp theo transaction | “Transaction pooling breaks anything that relies on session state.” |
| headroom | /ˈhed.ruːm/ | biên độ dự phòng | “We kept headroom under max_connections for rolling deploys.” |
| saturated | /ˈsætʃ.ə.reɪ.t̬ɪd/ | bão hoà | “Once the database is saturated, more connections only add contention.” |
Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.