Code Recipes Blog

In this post under Apache Pool, I will explain Apache Pool’s object retrieval strategy with example.

Whenever we request an object from an object pool, by default it follows LIFO (Last In First Out) strategy, to retrieve an idle object.

For example if in a pool, object are added in the below order and all of them are idle

Object1
Object2
Object3

When we query the pool for 3 objects in consequtive calls, it will be returned the objects in the below order

Object3
Object2
Object1

We can change the order by calling “setLifo” method on object pool configuration object.

Below is the complete code for your reference.

ThreadPooledObjectFactory

package package9;

import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;

public class ThreadPooledObjectFactory extends BasePooledObjectFactory<Thread> {
    private int count = 0;
    @Override
    public Thread create() throws Exception {
        String threadName = "Thread" + count;
        count = count + 1;
        return new Thread(threadName);
    }

    @Override
    public PooledObject<Thread> wrap(Thread obj) {
        return new DefaultPooledObject<Thread>(obj);
    }
}

Main class

1  package package9;
2  
3  import org.apache.commons.pool2.impl.GenericObjectPool;
4  import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
5  
6  public class Example9 {
7      public static void main(String[] args) throws Exception {
8          GenericObjectPoolConfig<Thread> genericObjectPoolConfig = new GenericObjectPoolConfig<Thread>();
9          genericObjectPoolConfig.setMaxTotal(5);
10         
11         ThreadPooledObjectFactory threadPooledObjectFactory = new ThreadPooledObjectFactory();
12         
13         GenericObjectPool<Thread> genericObjectPool = new GenericObjectPool<Thread>(threadPooledObjectFactory, genericObjectPoolConfig);
14         genericObjectPool.addObject();
15         genericObjectPool.addObject();
16         genericObjectPool.addObject();
17         genericObjectPool.addObject();
18         genericObjectPool.addObject();
19         
20         System.out.println("First Object pool LIFO strategy: " + genericObjectPoolConfig.getLifo());
21         
22         Thread thread1 = genericObjectPool.borrowObject();
23         System.out.println(thread1.getName());
24         
25         Thread thread2 = genericObjectPool.borrowObject();
26         System.out.println(thread2.getName());
27         
28         Thread thread3 = genericObjectPool.borrowObject();
29         System.out.println(thread3.getName());
30         
31         genericObjectPool.close();
32         
33         genericObjectPoolConfig = new GenericObjectPoolConfig<Thread>();
34         genericObjectPoolConfig.setMaxTotal(5);
35         genericObjectPoolConfig.setLifo(false);
36         
37         threadPooledObjectFactory = new ThreadPooledObjectFactory();
38         
39         genericObjectPool = new GenericObjectPool<Thread>(threadPooledObjectFactory, genericObjectPoolConfig);
40         genericObjectPool.addObject();
41         genericObjectPool.addObject();
42         genericObjectPool.addObject();
43         genericObjectPool.addObject();
44         genericObjectPool.addObject();
45         
46         System.out.println("Second Object pool LIFO strategy: " + genericObjectPoolConfig.getLifo());
47         
48         thread1 = genericObjectPool.borrowObject();
49         System.out.println(thread1.getName());
50         
51         thread2 = genericObjectPool.borrowObject();
52         System.out.println(thread2.getName());
53         
54         thread3 = genericObjectPool.borrowObject();
55         System.out.println(thread3.getName());
56         
57         genericObjectPool.close();
58     }
59 }

In the above code from line 8 to 31 we perform the following actions
1) Created an object pool with max items 5 and LIFO strategy enabled by default.
2) Inserted 5 idle objects in the pool
3) Then retrieved 3 objects and print there name
4) close the object pool

From line 33 to 57, we perform the following actions
1) Created an object pool with max items 5 and LIFO strategy disabled (this can be done by calling “setLifo” method on “GenericObjectPoolConfig” instance refer to line 35)
2) Inserted 5 idle objects in the pool
3) Then retrieved 3 objects and print there name
4) close the object pool

The output of the above code will be

Output

First Object pool LIFO strategy: true
Thread4
Thread3
Thread2
Second Object pool LIFO strategy: false
Thread0
Thread1
Thread2

From the output it can be seen that in first object pool, idle objects are retrieved in LIFO order and in the second output we can see idle objects are retrieved in non-LIFO order.