Creating Multiple Pools of Objects of Variable Size in Java

The object pool design pattern is a powerful tool for optimizing Java application performance and memory usage. It holds particular value when dealing with expensive-to-create objects or scenarios involving large numbers of objects.

The Object Pool design pattern in Java operates on the principle of reusing objects, particularly in situations where the creation of objects is resource-intensive and could lead to memory challenges when numerous objects are instantiated. The pattern is especially beneficial for enhancing application performance.

The underlying mechanism of the Object Pool design pattern revolves around object pooling. When multiple clients seek access to identical, stateless objects that are costly to create, the pattern employs a pool of reusable objects.

Object Pool Lifecycle

Creation: Objects are created and added to the pool during initialization. It is typically done when the application starts or when needed to reallocate resources.
Validation: Before providing an object from the pool, it is often validated to ensure it is still valid and usable. The step is crucial, especially if objects can become invalid over time.
Destroy: When an object is no longer needed or is deemed invalid, it is returned to the pool for potential reuse. If an object is no longer usable, it may be destroyed to free up resources.

How do you create Multiple pools of Objects?

Creating multiple pools of objects involves defining a manager or a class responsible for managing each pool. Below are the general steps to create multiple pools of objects:

Creating Multiple Pools of Objects of Variable Size in Java

Define a class for the objects you want to pool. The class should encapsulate the properties and behaviour of the objects.
Develop a class to represent the object pool. The class will manage the creation, retrieval, and release of objects.
Create instances of the object pool class for each type of object you want to pool. Each pool may have a different size or configuration.
The object pool class should keep track of available and in-use objects. It should provide methods to acquire an object from the pool and release it back into the pool.
In the client code or wherever you need these objects, obtain objects from the respective pools instead of creating new instances directly.

Real-time requirement

Memory allocation tailored for error handling or emergent scenarios in programming can be efficiently managed by creating multiple variable-size memory pools. Object pooling becomes crucial when certain objects, such as database connection objects, parser objects, or thread generation, appear to be relatively more expensive to produce due to their non-lightweight nature. Rather than incurring the overhead of creating new instances, these objects can be reused from a pool, mitigating the negative impact on program performance. By constructing multiple pools of objects, each accommodating the specific needs of resource-intensive entities, applications can

Implementation:

Filename: CustomThreadPool.java

import java.io.*;

// Represents a custom thread with a unique identifier
class CustomThread {
    private int uniqueId;
    private static int uniqueIDGen = 0;
    private String threadName;

    // Constructor for CustomThread
    CustomThread() {
        uniqueId = generateUniqueId();
    }

    // Setter method for thread name
    public void setThreadName(String name) {
        threadName = name;
    }

    // Getter method for thread name
    public String getThreadName() {
        return threadName;
    }

    // Generates a unique identifier for the thread
    private int generateUniqueId() {
        return uniqueIDGen++;
    }

    // Checks if two CustomThread instances are equal based on their unique identifiers
    public boolean isEqual(CustomThread t1) {
        return t1.uniqueId == this.uniqueId;
    }
}

// Represents a custom thread pool
class CustomThreadPool {
    private boolean isFirst = true;
    private CustomThread myThreads[] = null;
    private boolean isUsed[] = null;
    private int poolSize;
    private static int noOfThreadPools = 0;
    private int threadReferenceCount = 0;
    private int poolNum = 0;

    // Constructor for CustomThreadPool
    public CustomThreadPool() {
        noOfThreadPools++;
        poolNum = noOfThreadPools;
    }

    // Initializes the thread pool with a given size
    public boolean initializePool(int size) {
        boolean status = false;

        // Check if the pool is being initialized for the first time
        if (isFirst) {
            isFirst = false;
            poolSize = size;
            myThreads = new CustomThread[poolSize];

            // Creates threads and assigns names based on pool number
            for (int i = 0; i < poolSize; i++) {
                myThreads[i] = new CustomThread();
                String name = Integer.toString(i + 1);
                name = name.concat(" is the thread number of the pool ");
                name = name.concat(Integer.toString(poolNum));
                myThreads[i].setThreadName(name);
            }

            isUsed = new boolean[poolSize];

            // Initializes the isUsed array to false for all threads
            for (int i = 0; i < poolSize; i++) {
                isUsed[i] = false;
            }

            status = true;
        }

        return status;
    }

    // Acquires a reference to an available thread in the pool
    public CustomThread acquireThreadReference() {
        CustomThread threadToReturn = null;

        // Check if there are available threads in the pool
        if (threadReferenceCount < poolSize) {
            for (int i = 0; i < poolSize; i++) {
                if (!isUsed[i]) {
                    threadToReturn = myThreads[i];
                    isUsed[i] = true;
                    threadReferenceCount++;
                    break;
                }
            }
        }

        return threadToReturn;
    }

    // Releases the reference to a thread, making it available for reuse
    public void releaseThreadReference(CustomThread thread) {
        if (threadReferenceCount > 0) {
            for (int i = 0; i < poolSize; i++) {
                if (thread.isEqual(myThreads[i])) {
                    isUsed[i] = false;
                    threadReferenceCount--;
                    break;
                }
            }
        }
    }

    // Deinitializes the pool, freeing up resources
    public boolean deinitializePool() {
        boolean status = false;

        // Check if the pool is not being initialized for the first time
        if (!isFirst) {
            status = true;
        } else if (threadReferenceCount == 0) {
            // Clears resources when no threads are in use
            for (int i = 0; i < poolSize; i++) {
                myThreads[i] = null;
            }

            myThreads = null;
            isUsed = null;
            poolSize = 0;
            isFirst = true;
            status = true;
        }

        return status;
    }
}

// Main class to test the custom thread pool implementation
public class Main {
    public static void main(String[] args) {
        System.out.println("POOL1 Of Threads Created");

        CustomThreadPool pool1 = new CustomThreadPool();

        // Check if Pool 1 is successfully initialized
        if (pool1.initializePool(2)) {
            System.out.println("Pool 1 initialized");
        } else {
            System.out.println("Pool 1 not initialized");
        }

        CustomThread thread1 = pool1.acquireThreadReference();
        // Check if thread1 is successfully acquired
        if (thread1 != null) {
            System.out.println("Acquired: " + thread1.getThreadName());
        } else {
            System.out.println("Thread 1 does not refer to any object");
        }

        CustomThread thread2 = pool1.acquireThreadReference();
        // Check if thread2 is successfully acquired
        if (thread2 != null) {
            System.out.println("Acquired: " + thread2.getThreadName());
        } else {
            System.out.println("Thread 2 does not refer to any object");
        }

        CustomThread thread3 = pool1.acquireThreadReference();
        // Check if thread3 is successfully acquired
        if (thread3 != null) {
            System.out.println("Acquired: " + thread3.getThreadName());
        } else {
            System.out.println("Thread 3 does not refer to any object");
        }

        // Release thread1 and thread2
        pool1.releaseThreadReference(thread1);
        thread1 = null;
        pool1.releaseThreadReference(thread2);
        thread2 = null;

        // Try re-initializing Pool 1
        if (pool1.initializePool(2)) {
            System.out.println("Pool 1 re-initialized");
        } else {
            System.out.println("Pool 1 not initialized as it was already initialized\n");
        }

        System.out.println("POOL2 Of Threads Created");

        CustomThreadPool pool2 = new CustomThreadPool();

        // Initialize Pool 2 with 3 threads
        pool2.initializePool(3);

        CustomThread pool2Thread1 = pool2.acquireThreadReference();
        // Check if thread in Pool 2 is successfully acquired
        if (pool2Thread1 != null) {
            System.out.println("Acquired: " + pool2Thread1.getThreadName());
        } else {
            System.out.println("Thread 1 of Pool 2 does not refer to any object");
        }

        // Release thread in Pool 2
        pool2.releaseThreadReference(pool2Thread1);
        pool2Thread1 = null;

        // Deinitialize both pools
        pool1.deinitializePool();
        pool2.deinitializePool();
    }
}

Output:

POOL1 Of Threads Created
Pool 1 initialized
Acquired: 1 is the thread number of the pool 1
Acquired: 2 is the thread number of the pool 1
Thread 3 does not refer to any object
Pool 1 not initialized as it was already initialized

POOL2 Of Threads Created
Acquired: 1 is the thread number of the pool 2

Benefits of Object Pooling

Performance Improvement: Object pooling can significantly improve performance by reducing the overhead of creating and destroying objects.
Resource Efficiency: The system can manage resources more efficiently by reusing objects, especially when object creation is expensive.
Optimized Memory Usage: Since objects are reused, memory fragmentation can be minimized, leading to more efficient memory utilization.

Next TopicDefault Exception in Java

← prev next →