/ /

Connection Pools

Overview

In this guide, you can learn about how the Java driver uses connection pools to manage connections to a MongoDB deployment and how you can configure connection pool settings in your application.

A connection pool is a cache of open database connections maintained by the Java driver. When your application requests a connection to MongoDB, the Java driver seamlessly gets a connection from the pool, performs operations, and returns the connection to the pool for reuse.

Connection pools help reduce application latency and the number of times new connections are created by Java driver.

Create a Connection Pool

Every MongoClient instance has a built-in connection pool for each server in your MongoDB topology. Connection pools open sockets on demand to support concurrent MongoDB operations in your multi-threaded application.

The maxPoolSize option sets the maximum size of each connection pool, which defaults to 100. If the number of in-use connections to a server reaches the value of maxPoolSize, the next request to that server will wait until a connection becomes available.

Each MongoClient instance opens two more sockets per server in your MongoDB topology for monitoring the server's state.

Configure a Connection Pool

You can specify settings for your connection pool using either a connection string or by passing a MongoClientSettings object to the MongoClients.create() method.

Select the Connection String or MongoClientSettings tab to see the corresponding syntax:

The following are connection string settings you can use to configure your connection pool:

Setting	Description
`maxConnecting`	Maximum number of connections a pool may establish concurrently. Default: `2`
`maxIdleTimeMS`	The maximum number of milliseconds that a connection can remain idle in the pool before being removed and closed. Set this value higher than your application's expected idle period but lower than firewall or proxy connection timeouts to prevent unexpected disconnections. Default: `0`
`maxPoolSize`	Maximum number of connections opened in the pool. If an operation needs a new connection while the connection pool has `maxPoolSize` connections open, the new operation waits for a new connection to open. To limit this waiting time, use the single timeout setting. To learn more, see the Limit Server Execution Time guide. Default: `100`
`minPoolSize`	Minimum number of connections opened in the pool. The value of `minPoolSize` must be less than the value of `maxPoolSize`. Default: `0`
`waitQueueTimeoutMS` (deprecated)	This option is deprecated. You can configure this timeout by setting the the client-level timeout instead. Maximum wait time in milliseconds that an operation can wait for a connection to become available. A value of `0` means there is no limit. Default: `120000` (120 seconds)
`maxLifeTimeMS`	Specifies the maximum amount of time, in milliseconds, the Java driver will continue to use a pooled connection before closing the connection. A value of `0` indicates that there is no upper bound on how long the driver can keep a pooled connection open. Default: `0`

The following code creates a client with a maximum connection pool size of 50.

ConnectionString connectionString = "mongodb://<host>:<port>/?maxPoolSize=50"
MongoClient mongoClient = MongoClients.create(connectionString)

For more information about these parameters, see the ConnectionString API documentation.

Chain the applyToConnectionPoolSettings() method to modify the way the driver manages its connection pool.

The following table describes the methods you can chain to your settings to modify the driver's behavior:

Method	Description
`addConnectionPoolListener()`	Adds a listener for connection pool-related events.
`applyConnectionString()`	Uses the settings from a `ConnectionString` object.
`applySettings()`	Uses the connection pool settings specified in a `ConnectionPoolSettings` object.
`maintenanceFrequency()`	Sets the frequency for running a maintenance job.
`maintenanceInitialDelay()`	Sets the time to wait before running the first maintenance job.
`maxConnectionIdleTime()`	Sets the maximum time a connection can be idle before it's closed.
`maxConnectionLifeTime()`	Sets the maximum time a pooled connection can be alive before it's closed.
`maxSize()`	Sets the maximum number of connections associated with a connection pool. Default: `100`
`maxWaitTime()`	Sets the maximum time to wait for an available connection. Default: `2 minutes`
`minSize()`	Sets the minimum number of connections associated with a connection pool. Default: `0`

Note

This maxSize and minSize settings apply to each server in the cluster you connect the driver to.

For example, assume you connect the driver to a cluster with three mongos servers. This means that there can be at most maxSize connections and at least minSize connections to each mongos server.

The following example chains the applyToConnectionPoolSettings() method to set the thread to wait at most 10 SECONDS for an available connection, and the maxSize of the connection pool to 200:

MongoClient mongoClient = MongoClients.create(
    MongoClientSettings.builder().applyConnectionString(
        new ConnectionString("<your connection string>"))
    .applyToConnectionPoolSettings(builder ->
        builder.maxSize(50))
    .build());

Additional Information

For more information on using a connection pool, see the Connection Pool documentation in the Server manual.

Back

Limit Execution Time

Cluster Settings