by BehindJava

What is connection pooling in Java

Home » java » What is connection pooling in Java

In this tutorial we are going to learn in detail about connection pooling Java.


Connection pooling is a well-known data access pattern, whose main purpose is to reduce the overhead involved in performing database connections and read/write database operations.

In a nutshell, a connection pool is, at the most basic level, a database connection cache implementation, which can be configured to suit specific requirements.

In this tutorial, we’ll make a quick roundup of a few popular connection pooling frameworks, and we’ll learn how to implement from scratch our own connection pool.

Why Connection Pooling?

The question is rhetorical, of course.

If we analyze the sequence of steps involved in a typical database connection life cycle, we’ll understand why:

  • Opening a connection to the database using the database driver
  • Opening a TCP socket for reading/writing data
  • Reading / writing data over the socket
  • Closing the connection
  • Closing the socket

It becomes evident that database connections are fairly expensive operations, and as such, should be reduced to a minimum in every possible use case (in edge cases, just avoided).

Here’s where connection pooling implementations come into play.

By just simply implementing a database connection container, which allows us to reuse a number of existing connections, we can effectively save the cost of performing a huge number of expensive database trips, hence boosting the overall performance of our database-driven applications.

JDBC Connection Pooling Frameworks

From a pragmatic perspective, implementing a connection pool from the ground up is just pointless, considering the number of “enterprise-ready” connection pooling frameworks available out there.

From a didactic one, which is the goal of this article, it’s not.

Even so, before we learn how to implement a basic connection pool, let’s first showcase a few popular connection pooling frameworks.

Apache Commons DBCP

Let’s start this quick roundup with Apache Commons DBCP Component, a full-featured connection pooling JDBC framework:

public class DBCPDataSource {
    private static BasicDataSource ds = new BasicDataSource();
    static {
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    private DBCPDataSource(){ }

In this case, we’ve used a wrapper class with a static block to easily configure DBCP’s properties.

Here’s how to get a pooled connection with the DBCPDataSource class:

Connection con = DBCPDataSource.getConnection();


Moving on, let’s look at HikariCP, a lightning-fast JDBC connection pooling framework created by Brett Wooldridge (for the full details on how to configure and get the most out of HikariCP, please check this article):

public class HikariCPDataSource {
    private static HikariConfig config = new HikariConfig();
    private static HikariDataSource ds;
    static {
        config.addDataSourceProperty("cachePrepStmts", "true");
        config.addDataSourceProperty("prepStmtCacheSize", "250");
        config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
        ds = new HikariDataSource(config);
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    private HikariCPDataSource(){}

Similarly, here’s how to get a pooled connection with the HikariCPDataSource class:

Connection con = HikariCPDataSource.getConnection();


Last in this review is C3P0, a powerful JDBC4 connection and statement pooling framework developed by Steve Waldman:

public class C3p0DataSource {

    private static ComboPooledDataSource cpds = new ComboPooledDataSource();

    static {
        try {
        } catch (PropertyVetoException e) {
            // handle the exception
    public static Connection getConnection() throws SQLException {
        return cpds.getConnection();
    private C3p0DataSource(){}

As expected, getting a pooled connection with the C3p0DataSource class is similar to the previous examples:

Connection con = C3p0DataSource.getConnection();

A Simple Implementation

To better understand the underlying logic of connection pooling, let’s create a simple implementation.

Let’s start out with a loosely coupled design, based on just one single interface:

public interface ConnectionPool {
    Connection getConnection();
    boolean releaseConnection(Connection connection);
    String getUrl();
    String getUser();
    String getPassword();

The ConnectionPool interface defines the public API of a basic connection pool.

Now, let’s create an implementation, which provides some basic functionality, including getting and releasing a pooled connection:

public class BasicConnectionPool 
  implements ConnectionPool {

    private String url;
    private String user;
    private String password;
    private List<Connection> connectionPool;
    private List<Connection> usedConnections = new ArrayList<>();
    private static int INITIAL_POOL_SIZE = 10;
    public static BasicConnectionPool create(
      String url, String user, 
      String password) throws SQLException {
        List<Connection> pool = new ArrayList<>(INITIAL_POOL_SIZE);
        for (int i = 0; i < INITIAL_POOL_SIZE; i++) {
            pool.add(createConnection(url, user, password));
        return new BasicConnectionPool(url, user, password, pool);
    // standard constructors
    public Connection getConnection() {
        Connection connection = connectionPool
          .remove(connectionPool.size() - 1);
        return connection;
    public boolean releaseConnection(Connection connection) {
        return usedConnections.remove(connection);
    private static Connection createConnection(
      String url, String user, String password) 
      throws SQLException {
        return DriverManager.getConnection(url, user, password);
    public int getSize() {
        return connectionPool.size() + usedConnections.size();

    // standard getters

While pretty naive, the BasicConnectionPool class provides the minimal functionality that we’d expect from a typical connection pooling implementation.

In a nutshell, the class initializes a connection pool based on an ArrayList that stores 10 connections, which can be easily reused.

It’s possible to create JDBC connections with the DriverManager class and with Datasource implementations.

As it’s much better to keep the creation of connections database agnostic, we’ve used the former within the create() static factory method.

In this case, we’ve placed the method within the BasicConnectionPool, because this is the only implementation of the interface.

In a more complex design, with multiple ConnectionPool implementations, it’d be preferable to place it in the interface, therefore getting a more flexible design and a greater level of cohesion.

The most relevant point to stress here is that once the pool is created, connections are fetched from the pool, so there’s no need to create new ones.

Furthermore, when a connection is released, it’s actually returned back to the pool, so other clients can reuse it.

There’s no further interaction with the underlying database, such as an explicit call to the Connection’s close() method.

Using the BasicConnectionPool Class

As expected, using our BasicConnectionPool class is straightforward.

Let’s create a simple unit test and get a pooled in-memory H2 connection:

public whenCalledgetConnection_thenCorrect() {
    ConnectionPool connectionPool = BasicConnectionPool
      .create("jdbc:h2:mem:test", "user", "password");

Further Improvements and Refactoring

Of course, there’s plenty of room to tweak/extend the current functionality of our connection pooling implementation.

For instance, we could refactor the getConnection() method and add support for maximum pool size. If all available connections are taken and the current pool size is less than the configured maximum, the method will create a new connection.

Also, we could additionally verify whether the connection obtained from the pool is still alive before passing it to the client.

public Connection getConnection() throws SQLException {
    if (connectionPool.isEmpty()) {
        if (usedConnections.size() < MAX_POOL_SIZE) {
            connectionPool.add(createConnection(url, user, password));
        } else {
            throw new RuntimeException(
              "Maximum pool size reached, no available connections!");

    Connection connection = connectionPool
      .remove(connectionPool.size() - 1);

        connection = createConnection(url, user, password);

    return connection;

Note that the method now throws SQLException, meaning we’ll have to update the interface signature as well.

Or, we could add a method to gracefully shut down our connection pool instance:

public void shutdown() throws SQLException {
    for (Connection c : connectionPool) {

In production-ready implementations, a connection pool should provide a bunch of extra features, such as the ability to track the connections that are currently in use, support for prepared statement pooling, and so forth.

As we’ll keep things simple, we’ll omit how to implement these additional features and keep the implementation non-thread-safe for the sake of clarity.


In this article, we took an in-depth look at what connection pooling is and learned how to roll our own connection pooling implementation.

Of course, we don’t have to start from scratch every time that we want to add a full-featured connection pooling layer to our applications.

That’s why we first made a simple roundup showing some of the most popular connection pool frameworks, so we can have a clear idea of how to work with them and pick up the one that best suits our requirements.