Object Pool Design Pattern in Java

1. Definition

The Object Pool Design Pattern provides a mechanism to reuse objects that are expensive to create. It maintains a pool of objects that are initialized once and then can be borrowed and returned rather than being frequently created and destroyed.

2. Problem Statement

How can we efficiently manage and reuse objects which are expensive to create, rather than continuously creating and destroying them, leading to performance issues and increased system overhead?

3. Solution

Maintain a set of initialized objects in a pool. Clients borrow objects from this pool and return them when they are done, making them available for other clients.

4. Real-World Use Cases

1. Connection pools where establishing a connection is costly and time-consuming.

2. Thread pools for executing concurrent tasks without the overhead of continuously creating and destroying threads.

3. Reusing large graphics objects like bitmaps in a game.

5. Implementation Steps

1. Create an interface or abstract class representing the pooled object.

2. Implement a pool class that manages the creation, storage, and retrieval of these objects.

3. The pool class should have methods to "acquire" and "release" objects.

6. Implementation

// PooledObject class
class PooledObject {
    private String data;

    public PooledObject(String data) {
        this.data = data;

    public String getData() {
        return data;

// ObjectPool class
class ObjectPool {
    private List<PooledObject> available = new ArrayList<>();
    private List<PooledObject> inUse = new ArrayList<>();

    public PooledObject acquire() {
        if (available.isEmpty()) {
            available.add(new PooledObject("New Object"));
        PooledObject obj = available.remove(0);
        return obj;

    public void release(PooledObject obj) {

// Client
public class ObjectPoolDemo {
    public static void main(String[] args) {
        ObjectPool pool = new ObjectPool();
        PooledObject obj1 = pool.acquire();


        PooledObject obj2 = pool.acquire();


New Object
New Object


The Object Pool Pattern manages a collection of objects in memory. When the client requests an object, the pool provides one that's already initialized (or creates a new one if necessary). Once the client finishes using the object, it's returned to the pool, making it available for other clients.

7. When to use?

Use the Object Pool Pattern when:

1. The system works with a large number of objects that are expensive to instantiate and only needed for short periods.

2. Due to resource constraints, it's more feasible to reuse objects rather than continuously creating and destroying them.