Object Pool Pattern

Object Pool Pattern says that " to reuse the object that are expensive to create".

Basically, an Object pool is a container which contains a specified amount of objects. When an object is taken from the pool, it is not available in the pool until it is put back. Objects in the pool have a lifecycle: creation, validation and destroy.

Advantage of Object Pool design pattern

• It boosts the performance of the application significantly.
• It is most effective in a situation where the rate of initializing a class instance is high.
• It manages the connections and provides a way to reuse and share them.
• It can also provide the limit for the maximum number of objects that can be created.

Usage:

• When an application requires objects which are expensive to create. Eg: there is a need of opening too many connections for the database then it takes too longer to create a new one and the database server will be overloaded.
• When there are several clients who need the same resource at different times.

NOTE: Object pool design pattern is essentially used in Web Container of the server for creating thread pools and data source pools to process the requests.

Example of Object Pool Pattern:

Let's understand the example by the given UML diagram.

UML for Object Pool Pattern

Implementation of above UML:

Step 1

Create an ObjectPool class that is used to create the number of objects.

File: ObjectPool.java

1. import java.util.concurrent.ConcurrentLinkedQueue;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.ScheduledExecutorService;  
4. import java.util.concurrent.TimeUnit;  
5.   
6. public abstract class ObjectPool<T> {  
7. /* 
8.   pool implementation is based on ConcurrentLinkedQueue from the java.util.concurrent package. 
9.   ConcurrentLinkedQueue is a thread-safe queue based on linked nodes.  
10.    Because the queue follows FIFO technique (first-in-first-out). 
11.  */          
12.       
13.    private ConcurrentLinkedQueue<T> pool;  
14.          
15.  /*  
16.    
17.    ScheduledExecutorService starts a special task in a separate thread and observes 
18.    the minimum and maximum number of objects in the pool periodically in a specified  
19.     time (with parameter validationInterval).  
20.    When the number of objects is less than the minimum, missing instances will be created.  
21.    When the number of objects is greater than the maximum, too many instances will be removed.  
22.    This is sometimes useful for the balance of memory consuming objects in the pool. 
23. */  
24.     private ScheduledExecutorService executorService;  
25.        /* 
26.      * Creates the pool. 
27.      * 
28.      * @param minObjects : the minimum number of objects residing in the pool 
29.      */  
30.        
31.     public ObjectPool(final int minObjects)     {  
32.         // initialize pool  
33.           
34.         initialize(minObjects);  
35.           
36.     }  
37.       
38.     /* 
39.       Creates the pool. 
40.       @param minObjects:   minimum number of objects residing in the pool. 
41.       @param maxObjects:   maximum number of objects residing in the pool. 
42.       @param validationInterval: time in seconds for periodical checking of  
43.          minObjects / maxObjects conditions in a separate thread. 
44.       When the number of objects is less than minObjects, missing instances will be created. 
45.       When the number of objects is greater than maxObjects, too many instances will be removed. 
46.     */  
47.      public ObjectPool(final int minObjects, final int maxObjects, final long validationInterval) {  
48.         // initialize pool  
49.          initialize(minObjects);  
50.           // check pool conditions in a separate thread  
51.         executorService = Executors.newSingleThreadScheduledExecutor();  
52.         executorService.scheduleWithFixedDelay(new Runnable()   { // annonymous class    
53.             @Override  
54.             public void run() {  
55.                 int size = pool.size();  
56.                 if (size < minObjects) {  
57.                     int sizeToBeAdded = minObjects + size;  
58.                     for (int i = 0; i < sizeToBeAdded; i++) {  
59.                         pool.add(createObject());  
60.                     }  
61.                 } else if (size > maxObjects) {  
62.                     int sizeToBeRemoved = size - maxObjects;  
63.                     for (int i = 0; i < sizeToBeRemoved; i++) {  
64.                         pool.poll();  
65.                     }  
66.                 }  
67.             }  
68.         }, validationInterval, validationInterval, TimeUnit.SECONDS);  
69.     }  
70.       
71.   /* 
72.       Gets the next free object from the pool. If the pool doesn't contain any objects, 
73.       a new object will be created and given to the caller of this method back. 
74.       
75.       @return T borrowed object 
76.   */  
77.     public T borrowObject() {  
78.         T object;  
79.         if ((object = pool.poll()) == null)  {  
80.             object = createObject();  
81.         }  
82.         return object;  
83.     }  
84.  /* 
85.       Returns object back to the pool. 
86.       @param object object to be returned 
87.   */  
88.     public void returnObject(T object) {  
89.         if (object == null) {  
90.             return;  
91.         }  
92.         this.pool.offer(object);  
93.     }  
94.    /* 
95.         Shutdown this pool. 
96.     */  
97.       public void shutdown(){  
98.         if (executorService != null){  
99.             executorService.shutdown();  
100.         }  
101.     }  
102.     /* 
103.         Creates a new object. 
104.          @return T new object 
105.      */  
106.     protected abstract T createObject();  
107.   
108.     private void initialize(final int minObjects)  {  
109.         pool = new ConcurrentLinkedQueue<T>();  
110.         for (int i = 0; i < minObjects; i++) {  
111.             pool.add(createObject());  
112.         }  
113.     }  
114. }// End of the ObjectPool Class.  

Step 2

Create an ExportingProcess class that will be used by ExportingTask class.

File: ExportingProcess.java

1. public class ExportingProcess {  
2.  private long processNo;  
3.   
4.     public ExportingProcess(long processNo)  {  
5.          this.processNo = processNo;  
6.         // do some  expensive calls / tasks here in future  
7.         // .........  
8.       System.out.println("Object with process no. " + processNo + " was created");  
9.      }  
10.      
11.     public long getProcessNo() {  
12.         return processNo;  
13.     }  
14. }// End of the ExportingProcess class.  

Step 3

Create an ExportingTask class that will use ExportingProcess and ObjectPool class.

File: ExportingTask.java

1. public class ExportingTask implements Runnable {  
2.         private ObjectPool<ExportingProcess> pool;  
3.         private int threadNo;  
4.         public ExportingTask(ObjectPool<ExportingProcess> pool, int threadNo){  
5.             this.pool = pool;  
6.             this.threadNo = threadNo;  
7.         }  
8.       
9.         public void run() {  
10.             // get an object from the pool  
11.             ExportingProcess exportingProcess = pool.borrowObject();  
12.             System.out.println("Thread " + threadNo + ": Object with process no. "  
13.                     + exportingProcess.getProcessNo() + " was borrowed");  
14.   
15.             //you can  do something here in future  
16.             // .........  
17.   
18.                // return ExportingProcess instance back to the pool  
19.             pool.returnObject(exportingProcess);  
20.   
21.             System.out.println("Thread " + threadNo +": Object with process no. "  
22.                    + exportingProcess.getProcessNo() + " was returned");  
23.         }  
24.   
25.     }// End of the ExportingTask class.   

Step 4

Create an ObjectPoolDemo class.

File: ObjectPoolDemo.java

1. import java.util.concurrent.ExecutorService;  
2. import java.util.concurrent.Executors;  
3. import java.util.concurrent.TimeUnit;  
4. import java.util.concurrent.atomic.AtomicLong;  
5. public class ObjectPoolDemo{  
6.       private ObjectPool<ExportingProcess> pool;  
7.       private AtomicLong processNo=new AtomicLong(0);  
8.       public void setUp() {  
9.             // Create a pool of objects of type ExportingProcess.  
10.            /*Parameters: 
11.              1) Minimum number of special ExportingProcess instances residing in the pool = 4 
12.              2) Maximum number of special ExportingProcess instances residing in the pool = 10 
13.              3) Time in seconds for periodical checking of minObjects / maxObjects conditions 
14.                 in a separate thread = 5. 
15.              -->When the number of ExportingProcess instances is less than minObjects,  
16.                  missing instances will be created. 
17.              -->When the number of ExportingProcess instances is greater than maxObjects, 
18.                   too many instances will be removed. 
19.             -->If the validation interval is negative, no periodical checking of  
20.                   minObjects / maxObjects conditions in a separate thread take place. 
21.               These boundaries are ignored then. 
22.            */  
23.       pool = new ObjectPool<ExportingProcess>(4, 10, 5) {  
24.             protected ExportingProcess createObject() {  
25.                 // create a test object which takes some time for creation  
26.                 return new ExportingProcess( processNo.incrementAndGet());  
27.             }  
28.         };  
29.     }  
30.     public void tearDown() {  
31.         pool.shutdown();  
32.     }  
33.     public void testObjectPool() {  
34.         ExecutorService executor = Executors.newFixedThreadPool(8);  
35.   
36.         // execute 8 tasks in separate threads  
37.           
38.         executor.execute(new ExportingTask(pool, 1));  
39.         executor.execute(new ExportingTask(pool, 2));  
40.         executor.execute(new ExportingTask(pool, 3));  
41.         executor.execute(new ExportingTask(pool, 4));  
42.         executor.execute(new ExportingTask(pool, 5));  
43.         executor.execute(new ExportingTask(pool, 6));  
44.         executor.execute(new ExportingTask(pool, 7));  
45.         executor.execute(new ExportingTask(pool, 8));  
46.   
47.         executor.shutdown();  
48.         try {  
49.             executor.awaitTermination(30, TimeUnit.SECONDS);  
50.             } catch (InterruptedException e)  {  
51.                e.printStackTrace();  
52.               }  
53.     }  
54.     public static void main(String args[])  {   
55.         ObjectPoolDemo op=new ObjectPoolDemo();  
56.         op.setUp();  
57.         op.tearDown();  
58.         op.testObjectPool();  
59.    }   
60. }//End of the ObjectPoolDemo class.  

Output