연결 풀링 및 동시성 튜닝

Every concurrent request consumes a thread, a connection, and memory. When these run out, requests queue and latency explodes. Concurrency tuning is about sizing these resources to match real demand.

Opening a database or HTTP connection is expensive. A connection pool keeps a set of reusable connections so requests borrow and return them instead of creating new ones each time.

If the pool is smaller than concurrent demand, requests wait for a free connection. You see high latency with low CPU, the classic sign of pool starvation.

An oversized pool overwhelms the database with more connections than it can serve, causing context-switching and memory pressure. Bigger is not always better.

A common starting formula for a DB pool is based on available cores and disk concurrency. Measure under load and adjust; the goal is to keep connections busy without queuing at the database.

Web servers and app frameworks also have thread or worker pools. These must align with the connection pool, otherwise threads pile up waiting for connections.

For HTTP clients, enabling keep-alive reuses TCP connections across requests, cutting handshake overhead. Verify your client is actually reusing sockets under load.

Always set acquisition and query timeouts. Without them, a saturated pool causes threads to block indefinitely, turning a slowdown into a full outage.

When demand exceeds capacity, it is better to reject or shed load quickly than to let everything queue. Fast failure with backpressure keeps the system responsive for the requests it can serve.

Tune iteratively: change the pool size, run the same load test, and watch latency and the connection-wait metric. Repeat until throughput plateaus without latency spikes.

Expose and watch the pool-wait time and active-connection count metrics during tests. A rising wait time is the earliest signal that the pool is becoming a bottleneck.

You learned to tune concurrency and pooling.

• Size connection and thread pools to match real demand, not just bigger.
• Set timeouts and prefer backpressure over unbounded queuing.
• Validate every change with repeatable load tests.