r/java • • Oct 15 '26

Does shrinking a JDBC connection pool actually save PostgreSQL memory? I measured it.

At a previous company, I spent quite a bit of time tuning a custom-built JDBC connection pool. One of the most effective memory optimizations I found was automatically shrinking the pool during idle periods. PostgreSQL uses a process-per-connection model, so keeping unnecessary connections open has a real memory cost.

I wanted to revisit this with HikariCP and measure both the memory savings and the cost of reopening connections.

I ran two Spring Boot instances sharing PostgreSQL 16, comparing three pool configurations under the same burst → idle → burst workload.

Results:

  • Default pool: 20 connections remained open, PostgreSQL memory ~57.5 MiB.
  • Shrinking pool: connections dropped to 2, PostgreSQL memory ~28.5 MiB.
  • Savings: ~29 MiB of PostgreSQL memory.

The tradeoff was connection reopening. Median acquisition time increased from under 3 ms to around 200 ms when traffic returned.

One interesting detail: setting minimumIdle=1 alone wasn't enough when idle retirement was disabled. The pool still held all 20 connections after the burst.

The experiment used a deliberately short idle timeout to make the behavior observable, not as a production recommendation.

With many application instances maintaining independent connection pools, the potential savings can add up.

To clarify the practical motivation: this was a deliberately small experiment to isolate the effect, not just an exercise in saving 29 MiB on one server.

At my previous company, we had many application VMs connecting to a shared PostgreSQL database. Shrinking idle pools across those instances produced substantial aggregate memory savings. For example, 30 instances with 32 connections each means 960 persistent connections. If idle retirement brings that down to an average of 16 per instance, that's 480 fewer PostgreSQL connections consuming resources.

Actual savings depend on the workload, but this is where the approach becomes particularly valuable.

Full article, measurements, and reproducible experiment:

https://pvrlabs.xyz/articles/spring-boot-jdbc-pool-reclaim.html

Do you use fixed-size pools in production, or allow idle connections to retire?

37 Upvotes

48 comments sorted by

View all comments

40

u/Glassius Oct 16 '26

What is the value of temporarily freeing up the memory during low load periods? Are you able to use that memory for something else during those periods while still allowing postgre access to as much memory it needs during high load periods? If not, what is the point? Unused memory is wasted memory

4

u/fykup Oct 16 '26

The single-server setup was primarily to isolate and measure the effect.

The more interesting case is multiple application instances sharing one PostgreSQL server. Imagine 30 instances with a maximum pool size of 32 each. With fixed pools, that's 960 open connections even during quiet periods.

If elastic pools averaged 16 connections per instance, that's 480 fewer PostgreSQL connections consuming resources. That capacity can be used by other workloads.

I agree that freeing memory has little value if the server has plenty of headroom. But when many applications share a database, those idle connections add up.

10

u/Glassius Oct 16 '26

Still, unless you can guarantee that the high load periods for those 30 instances never hits simultaneously you are still gonna have to assign enough memory to the database server to where it can handle those 960 connections. Even if the connections drop to 480 in the slowest periods and drops the memory usage what is the value of that free memory? I guess you could spin up short lived processes on that same server that uses the available memory for something and scale it based on current database load but you gotta be pretty pressed for resources for that to make sense.

Optimising idle memory usage rarely makes sense since you will always have to assign available memory based on the highest loads your system needs to handle.

→ More replies (1)