Creating Multiple Pools of Objects of Variable Size in Java

// Java Program to Creating Multiple Pools Of Objects of
// Variable Size

// Importing required classes
import java.io.*;
import java.util.*;

// Class 1
// Helper class
class Thread {

    // Members of this class
    private int uniqueId;
    private static int uniqueIDGen = 0;
    private String thread_name;

    // Constructor that initializes the objects of Thread
    // class
    Thread() { uniqueId = generateUniqueId(); }

    // Method 1
    // To set the value of the data member,
    // name of the Thread's Object
    public void setNameOfThread(String name)
    {
        thread_name = name;
    }

    // Method 2
    public String getNameOfThread() { return thread_name; }

    // Method 3
    // To generate a unique id for each Thread's Object
    private int generateUniqueId() { return uniqueIDGen++; }

    // Method 4
    // To Compare that the "this" reference and
    // "t1" reference refer to same object
    public boolean compare(Thread t1)
    {

        if (t1.uniqueId == this.uniqueId) {
            return true;
        }

        else {
            return false;
        }
    }
}

// Class 2
// Helper class
class ThreadPool {

    // member variables of this class

    // To keep true whenever 1st object of a pool is
    // created,
    // after 1st object creation, it is set to false
    private boolean isFirst = true;

    // Array reference of myThread (Thread Pool Array)
    private Thread myThreads[] = null;

    // Array to Keep track that which Thread's objects
    // are in use currently
    private boolean isUsed[] = null;

    private int n;

    // To keep count of no of Thread Pools and
    // is a class level Property
    private static int noOfThreadPools = 0;

    // Keeping count of no of thread references
    // in a particular pool
    private int ThreadreferenceCount = 0;

    // To Give a unique number to every Pool Created
    private int poolNum = 0;

    // Constructor of class 2
    public ThreadPool()
    {

        noOfThreadPools++;
        poolNum = noOfThreadPools;
    }

    // Method 1
    // To give "size" of each Thread pool and
    // creating size no of objects of Thread Type,
    // returning true if successful, else false
    public boolean initialize(int size)
    {

        boolean status = false;

        if (true == isFirst) {

            isFirst = false;
            n = size;

            // Assign memory of reference of array
            // using new keyword
            myThreads = new Thread[n];

            for (int i = 0; i < n; i++) {

                // Creating new object in heap of Thread
                // Class & myThread[i] reference refer it
                myThreads[i] = new Thread();

                // we are assigning thread name to each
                // thread
                String name = Integer.toString(i + 1);

                name = name.concat(
                    " is the thread number of the pool ");
                name = name.concat(
                    Integer.toString(poolNum));

                // Name assigning finishes
                myThreads[i].setNameOfThread(name);
            }

            // Creating new array of boolean type which is
            // referred by isUsed reference
            isUsed = new boolean[n];

            for (int i = 0; i < n; i++) {

                // Now making isUsed false for all the
                // references false,
                // false because when initializing, no
                // reference from outside is referring to
                // any of the objects created (from o to
                // size-1)
                isUsed[i] = false;
            }

            status = true;
        }

        return status;
    }

    // Method 2
    // To get reference of the Thread Objects Present in the
    // Pool If no object is free, it returns null
    public Thread getReference()
    {

        Thread threadToReturn = null;

        if (ThreadreferenceCount < n) {

            for (int i = 0; i < n; i++) {

                // When no reference from outside the class
                // is referring to object myThread[i],
                // isUsed[i] is false
                if (false == isUsed[i]) {

                    threadToReturn = myThreads[i];

                    // Make isUsed[i] as true because we are
                    // returning a reference to the object
                    // referred by myThread[i]
                    isUsed[i] = true;

                    // Incrementing the count because we are
                    // returning a reference to the object
                    // referred by myThread[i] to outside
                    // world now this object cant be referred
                    // by another reference from outside
                    ThreadreferenceCount++;

                    // Break keyword
                    break;
                }
            }
        }

        return threadToReturn;
    }

    // Method 3
    // To release the outside world reference;
    // Here : "thread" - passed as parameter
    public void releaseReference(Thread thread)
    {

        if (ThreadreferenceCount > 0) {

            for (int i = 0; i < n; i++) {

                // Compare the "thread" parameter with every
                // reference and release the matched one by
                // making isUsed[i] = false;
                if (true == thread.compare(myThreads[i])) {

                    // Make isUsed[i] is false to show no
                    // reference from
                    // outside the class is referring to
                    // object myThread[i]
                    isUsed[i] = false;

                    // Decrementing the count because we are
                    // releasing a reference to the object
                    // in outside world

                    ThreadreferenceCount--;

                    break;
                }
            }
        }
    }

    // Method 4
    // To make all the objects free for garbage collection
    // To restore to initial situation
    public boolean deInitialize()
    {

        boolean status = false;

        if (isFirst = false) {
            status = true;
        }

        // This condition is not required if one wants to
        // deinitialize() even if the references are present
        // outside
        else if (ThreadreferenceCount == 0) {

            for (int i = 0; i < n; i++) {
                myThreads[i] = null;
            }

            myThreads = null;
            isUsed = null;

            n = 0;
            isFirst = true;
            status = true;
        }

        return status;
    }
}

// Class 3
// Min class
public class Main {

    // Main driver method
    public static void main(String[] args)
    {

        // Display message on console for better readability
        System.out.println(
            "*****************POOL1 Of Threads Created*****************");

        // Creating object of class 2 in class 3 main()
        // method
        ThreadPool p1 = new ThreadPool();

        // Creating pool of 2 objects
        if (p1.initialize(2)) {

            System.out.println("Pool 1 initialized");
        }
        else {

            System.out.println("Pool 1 not initialized");
        }

        // Now getting 2 references to the 2 Objects from
        // this pool

        // Thread 1
        Thread t1 = p1.getReference();
        if (t1 != null) {

            System.out.println(t1.getNameOfThread());
        }
        else {

            System.out.println(
                " t1 do not refer any object");
        }

        // Thread 2
        Thread t2 = p1.getReference();
        if (t2 != null) {

            System.out.println(t2.getNameOfThread());
        }
        else {

            System.out.println(
                " t2 do not refer any object");
        }

        // Thread 3
        Thread t3 = p1.getReference();
        if (t3 != null) {

            System.out.println(t3.getNameOfThread());
        }
        else {

            System.out.println(
                " t3 do not refer any object");
        }

        // Releasing all the references of pool 1
        p1.releaseReference(t1);
        t1 = null;
        p1.releaseReference(t2);
        t2 = null;

        // As we have not used deInitialize() method, we
        // cannot initialize the pool p1 again
        if (p1.initialize(2)) {

            // Print statement
            System.out.println("Pool 1 initialized");
        }
        else {

            // Print statement
            System.out.println(
                "Pool 1 not initialized as it was already initialized\n");
        }

        // Creating pool 2

        // Display message on console for better readability
        System.out.println(
            "*****************POOL2  Of Threads Created*****************");

        ThreadPool p2 = new ThreadPool();

        // Creating pool of 3 objects
        p2.initialize(3);

        Thread tp1 = p2.getReference();

        if (tp1 != null) {

            System.out.println(tp1.getNameOfThread());
        }
        else {

            System.out.println(
                "tp1 dont refer to any object");
        }

        // Releasing references of pool 2
        p2.releaseReference(tp1);
        tp1 = null;

        // Deinitializing both the pools
        // using deInitialize() method
        p1.deInitialize();
        p2.deInitialize();
    }
}