Connection pooling
Connection pooling is a resource-management technique that maintains a collection of established connections for reuse across multiple operations.
Python Concurrency with asyncio
Connection pooling is the practice of maintaining reusable network connections so multiple operations can share them.
- How it is used
- Improves I/O-bound web and database applications by reusing connections across multiple operations.
- How deep it goes
- Explains caching, acquisition, release, finite capacity, waiting, and concurrent execution, without detailing pool internals.
- Examples
- Uses aiohttp sessions, asyncpg product queries, a 100,000-SKU dataset, and sequential-versus-concurrent timing.
- What you can do after
- Apply it via asyncpg and asyncio to execute independent database queries concurrently while reusing bounded connections.
Read how Python Concurrency with asyncio explains connection pooling →
.NET in Action, Second Edition
A connection pool is a managed collection of reusable network connections that limits and coordinates simultaneous access.
- How it is used
- Explains why a search issuing thousands of asynchronous HTTP requests need not exhaust network sockets.
- How deep it goes
- Identifies HttpClient’s control of simultaneous calls but does not show pool configuration or internals.
- Examples
- Uses a comic-title search that creates more than 2,600 request tasks and waits with Task.WhenAll.
- What you can do after
- Evaluate/understand why many queued asynchronous HTTP tasks do not imply equally many simultaneous calls.
Read how .NET in Action, Second Edition explains connection pooling →
Rust Servers, Services, and Apps
A connection pool is a managed collection of reusable database connections shared among clients or execution threads.
- How it is used
- Deploys reusable database connectivity in an asynchronous Actix Web service and exposes it to request handlers through application state.
- How deep it goes
- Explains creation, state injection, handler access, and query execution, while deferring pool configuration and internal reuse mechanics.
- Examples
- Uses tutor course APIs, registration handlers, DATABASE_URL, PgPool, AppState, and independently buildable implementation iterations.
- What you can do after
- Build it from scratch by creating a sqlx pool, injecting it into Actix state, and using it in database-access functions.
Read how Rust Servers, Services, and Apps explains connection pooling →
Logs and Telemetry
Connection pooling is the practice of maintaining reusable database connections so operations can execute without repeatedly establishing new connections.
- How it is used
- Routes Fluent Bit log events into PostgreSQL with concurrent database writes.
- How deep it goes
- Explains async activation, minimum and maximum pool sizing, ordering consequences, and load testing without detailing pool internals.
- Examples
- Uses a Fluent Bit PostgreSQL output configuration, pgAdmin record retrieval, and LogSimulator load generation.
- What you can do after
- Operate/configure it by enabling async output and setting min_pool_size and max_pool_size for PostgreSQL writes.
Elixir in Action, Third Edition
A database connection pool is a bounded collection of reusable database connections managed to constrain simultaneous database operations.
- How it is used
- Constrains database operations when unrestricted concurrency could overload disk I/O or another limited resource.
- How deep it goes
- Explains coordinator state, worker delegation, distribution strategies, stable key routing, and interface preservation.
- Examples
- Uses three workers, PID maps, stable key selection, and Todo.Database forwarding get and store requests.
- What you can do after
- Build a three-worker database pool while preserving the existing public interface and per-key synchronization.
Read how Elixir in Action, Third Edition explains connection pooling →
Go by Example
A connection pool is a managed collection of reusable network connections maintained to avoid repeatedly establishing new connections.
- How it is used
- Reduces repeated database and HTTP connection setup by reusing managed connections across operations.
- How deep it goes
- Explains pool initialization, selection, lifecycle retention, and four database tuning controls without detailing their numeric trade-offs.
- Examples
- Demonstrates a SQLite Dial function using sql.Open and PingContext, plus HTTP requests sharing an http.Transport.
- What you can do after
- Apply it via *sql.DB and http.Transport by retaining shared handles and optionally configuring database pool limits.
PostgreSQL Mistakes and How to Avoid Them
Connection pooling is a technique that reuses a bounded set of database connections to serve a larger number of client requests.
- How it is used
- Controls application concurrency to preserve PostgreSQL performance during load spikes.
- How deep it goes
- Explains queueing, pooler behavior, monitoring signals, and process-level performance costs.
- Examples
- Uses PgBouncer, pg_stat_activity, a 5,000-connection observation, and pgbench client-count benchmarks.
- What you can do after
- Operate/configure application connection limits and diagnose excessive concurrency with PostgreSQL monitoring.
Read how PostgreSQL Mistakes and How to Avoid Them explains connection pooling →
100 Go Mistakes and How to Avoid Them
A database connection pool is a managed collection of reusable database connections that are allocated to operations and returned for later use.
- How it is used
- Uses managed reuse to control database and HTTP connection creation under concurrent or bursty workloads.
- How deep it goes
- Explains pool states, allocation, waiting, and four database limits, then contrasts HTTP idle and per-host limits.
- Examples
- Uses a five-connection database pool and 100 requests to one HTTP host to expose reuse and reconnection behavior.
- What you can do after
- Operate and configure database or HTTP pools by matching connection limits and idle policies to workload and backend capacity.
Read how 100 Go Mistakes and How to Avoid Them explains connection pooling →
ASP.NET Core in Action, 3e
Connection pooling is the reuse of established network connections across multiple client requests to reduce connection-setup overhead.
- How it is used
- Reduces socket and connection-management problems when applications call remote APIs.
- How deep it goes
- Explains handler lifetime, pooling, and recycling, but defers detailed manual SocketsHttpHandler configuration.
- Examples
- Uses an ASP.NET Core endpoint calling https://example.com/rates/latest through a factory-created HttpClient.
- What you can do after
- Operate pooled HTTP clients through IHttpClientFactory in dependency-injected .NET applications.
Read how ASP.NET Core in Action, 3e explains connection pooling →
Related concepts
- database connectionuses · A database connection is an active communication channel or session through which software sends operations to and receives results from a database system.
- connection poolerimplemented by · A connection pooler is software that maintains reusable database connections and assigns them to application requests as needed.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.