Apache Commons-pool2
1.简介
apache common pool2 作为对象池模式的一种实现，通过重用来分摊复杂对象的创建代价。被广泛应用在各种数据库连接池，线程池以及请求分发池中；其实现提供了一些参数来控制对象池的行为。
对象池模式解决的问题：管理那些代表的现实资源或者通过重用来分摊昂贵初始化代价的对象。对象的创建和销毁在一定程度上会消耗系统的资源，对于多数对象来说，没有必要利用对象池技术来进行对象的创建和管理。但是对于有些对象来说，其创建的代价还是比较昂贵的，比如线程、tcp连接、数据库连接等对象，因此对象池技术有其存在的意义。
对象池模式管理一个可代替对象的集合。组件从池中借出对象，用它来完成一些任务并当任务完成时归还该对象。被归还的对象接着满足请求，不管是同一个组件还是其他组件的请求。
2.组成
Common-pool2由三大模块组成：ObjectPool、PooledObject和PooledObjectFactory。
- PooledObject：池化对象，是需要放到ObjectPool对象的一个包装类。添加了一些附加的信息，比如说状态信息，创建时间，激活时间，关闭时间等
- PooledObjectFactory：工厂类，负责具体对象的创建、初始化，对象状态的销毁和验证。工厂产生的也是池化对象，而不是真正对象。
- ObjectPool：实现对对象存取和状态管理的池实现；如：线程池、数据库连接池，提供出去的对象是真正对象，而不是池化对象；池化对象是对象池的概念，为管理真正对象的相关细节提供支持。
用一句话来概括他们整体的关系就是factory创建需要放入pool的对象，经过PooledObject包装一下就可以上架了。
通常，ObjectPool会持有PooledObjectFactory，将具体的对象的创建、初始化、销毁等任务委托给PooledObjectFactory处理，工厂操作的对象是PooledObject，即具体的Object的包装类。因此，获取对象依赖ObjectPool而不是PooledObjectFactory。
3.ObjectPool
ObjectPool类族包含了以ObjectPool为代表的一系列pool，其中最主要的两类就是ObjectPool和KeyedObjectPool，他们分别针对普通的pool和以名值对映射的pool。
从图里头我们可以看到，真正定义的接口就是ObjectPool和KeyedObjectPool，具体的实现里有GenericObjectPool, GenericKeyedObjectPool和SoftReferenceObjectPool。
public interface ObjectPool<T> {
//从池中获取对象
T borrowObject() throws Exception, NoSuchElementException, IllegalStateException;
//将对象放回池中
void returnObject(T obj) throws Exception;
//废弃对象
void invalidateObject(T obj) throws Exception;
//添加对象
void addObject() throws Exception, IllegalStateException, UnsupportedOperationException;
//获取空闲对象个数
int getNumIdle();
//获取活跃对象个数
int getNumActive();
//清除池，池可用
void clear() throws Exception, UnsupportedOperationException;
//关闭池，池不可用
void close();
}
这部分的代码很简单直接，主要就是包含了一个pool需要的基本操作功能，比如从pool里取对象的borrowObject，返回对象到pool里的returnObject，还有一些查找里面可用对象数量以及管理pool的方法。这里的clear方法是用来清空里面处于idle状态的对象，而close方法则用来关闭整个pool。他们两者的一个典型差别就是clear之后里面没有可以用的对象了，我们需要再创建一些对象放进去。而close之后则连pool都访问不了了。
与ObjectPool对象的一个是KeyedObjectPool，它的操作方法基本上和ObjectPool一样，唯一的差别是它是基于key来操作的，所以所有相关的borrowObject, returnObject等操作都要提供key参数。
4.PooledObject
PooledObject主要是对需要被加入到pool里的对象提供一个包装，方便来查看或者统计一些对象信息，比如某个对象创建的时间，空闲时间以及活跃时间等。下面是PooledObject相关的类关系图：
public interface PooledObject<T> extends Comparable<PooledObject<T>> {
//获取到实际的对象
T getObject();
long getCreateTime();
long getActiveTimeMillis();
long getIdleTimeMillis();
long getLastBorrowTime();
long getLastReturnTime();
long getLastUsedTime();
@Override
int compareTo(PooledObject<T> other);
@Override
boolean equals(Object obj);
@Override
int hashCode();
@Override
String toString();
boolean startEvictionTest();
boolean endEvictionTest(Deque<PooledObject<T>> idleQueue);
boolean allocate();
boolean deallocate();
void invalidate();
void setLogAbandoned(boolean logAbandoned);
void use();
void printStackTrace(PrintWriter writer);
PooledObjectState getState();
void markAbandoned();
void markReturning();
}
5.PooledObjectFactory
在commons-pool2里专门抽象出来一个创建和销毁对象的接口PooledObjectFactory。而具体对象的创建则由用户自定义实现。
这里的设计假定所有在pool里可以被立马拿出去用的对象是一个idle状态，在拿到之后要用activateObject方法来激活一下。而对象要返回给pool的时候则要用passivateObject方法将它钝化。
public interface PooledObjectFactory<T> {
// 创建一个新对象;当对象池中的对象个数不足时,将会使用此方法来"输出"一个新的"对象",并交付给对象池管理
PooledObject<T> makeObject() throws Exception;
// 销毁对象,如果对象池中检测到某个"对象"idle的时间超时,或者操作者向对象池"归还对象"时检测到"对象"已经无效,那么此时将会导致"对象销毁";
// "销毁对象"的操作设计相差甚远,但是必须明确:当调用此方法时,"对象"的生命周期必须结束.如果object是线程,那么此时线程必须退出;
// 如果object是socket操作,那么此时socket必须关闭;如果object是文件流操作,那么此时"数据flush"且正常关闭.
void destroyObject(PooledObject<T> p) throws Exception;
// 检测对象是否"有效";Pool中不能保存无效的"对象",因此"后台检测线程"会周期性的检测Pool中"对象"的有效性,如果对象无效则会导致此对象从Pool中移除,并destroy;
// 此外在调用者从Pool获取一个"对象"时,也会检测"对象"的有效性,确保不能讲"无效"的对象输出给调用者;
// 当调用者使用完毕将"对象归还"到Pool时,仍然会检测对象的有效性.所谓有效性,就是此"对象"的状态是否符合预期,是否可以对调用者直接使用;
// 如果对象是Socket,那么它的有效性就是socket的通道是否畅通/阻塞是否超时等.
boolean validateObject(PooledObject<T> p);
// "激活"对象,当Pool中决定移除一个对象交付给调用者时额外的"激活"操作,比如可以在activateObject方法中"重置"参数列表让调用者使用时感觉像一个"新创建"的对象一样;如果object是一个线程,可以在"激活"操作中重置"线程中断标记",或者让线程从阻塞中唤醒等;
// 如果object是一个socket,那么可以在"激活操作"中刷新通道,或者对socket进行链接重建(假如socket意外关闭)等.
void activateObject(PooledObject<T> p) throws Exception;
// "钝化"对象,当调用者"归还对象"时,Pool将会"钝化对象"；钝化的言外之意,就是此"对象"暂且需要"休息"一下.
// 如果object是一个socket,那么可以passivateObject中清除buffer,将socket阻塞;如果object是一个线程,可以在"钝化"操作中将线程sleep或者将线程中的某个对象wait.需要注意的时,activateObject和passivateObject两个方法需要对应,避免死锁或者"对象"状态的混乱.
void passivateObject(PooledObject<T> p) throws Exception;
}
6.GenericObjectPoolConfig参数配置类
这个类允许使用者对对象池的一些参数进行调整，根据需要定制对象池。参数如下：
- lifo：对象池存储空闲对象是使用的LinkedBlockingDeque，它本质上是一个支持FIFO和FILO的双向的队列，common-pool2中的LinkedBlockingDeque不是Java原生的队列，而有common-pool2重新写的一个双向队列。如果为true，表示使用FIFO获取对象。默认值是true.建议使用默认值。
- fairness：common-pool2实现的LinkedBlockingDeque双向阻塞队列使用的是Lock锁。这个参数就是表示在实例化一个LinkedBlockingDeque时，是否使用lock的公平锁。默认值是false，建议使用默认值。
- maxWaitMillis：当没有空闲连接时，获取一个对象的最大等待时间。如果这个值小于0，则永不超时，一直等待，直到有空闲对象到来。如果大于0，则等待maxWaitMillis长时间，如果没有空闲对象，将抛出NoSuchElementException异常。默认值是-1；可以根据需要自己调整，单位是毫秒。
- minEvictableIdleTimeMillis：对象最小的空闲时间。如果为小于等于0，最Long的最大值，如果大于0，当空闲的时间大于这个值时，执行移除这个对象操作。默认值是1000L * 60L * 30L;即30分钟。这个参数是强制性的，只要空闲时间超过这个值，就会移除。
- softMinEvictableIdleTimeMillis：对象最小的空间时间，如果小于等于0，取Long的最大值，如果大于0，当对象的空闲时间超过这个值，并且当前空闲对象的数量大于最小空闲数量(minIdle)时，执行移除操作。这个和上面的minEvictableIdleTimeMillis的区别是，它会保留最小的空闲对象数量。而上面的不会，是强制性移除的。默认值是-1；
- numTestsPerEvictionRun：检测空闲对象线程每次检测的空闲对象的数量。默认值是3；如果这个值小于0,则每次检测的空闲对象数量等于当前空闲对象数量除以这个值的绝对值，并对结果向上取整。
- testOnCreate：在创建对象时检测对象是否有效，true是，默认值是false。
- testOnBorrow：在从对象池获取对象时是否检测对象有效，true是；默认值是false。
- testOnReturn：在向对象池中归还对象时是否检测对象有效，true是，默认值是false。
- testWhileIdle：在检测空闲对象线程检测到对象不需要移除时，是否检测对象的有效性。true是，默认值是false。
- timeBetweenEvictionRunsMillis：空闲对象检测线程的执行周期，即多长时候执行一次空闲对象检测。单位是毫秒数。如果小于等于0，则不执行检测线程。默认值是-1;
- blockWhenExhausted：当对象池没有空闲对象时，新的获取对象的请求是否阻塞。true阻塞。默认值是true;
- maxTotal：对象池中管理的最多对象个数。默认值是8。
- maxIdle：对象池中最大的空闲对象个数。默认值是8。
- minIdle：对象池中最小的空闲对象个数。默认值是0。
7.简单使用
1.maven导入（目前最新为2.8.0）
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.8.0</version>
</dependency>
2.创建一个需要被管理的对象
public class MyObject {
//记录取出的次数
private int num;
//激活状态
private boolean active;
private long time;
public MyObject(){
active = true;
time = System.currentTimeMillis();
System.out.println("New MyObject！！！");
}
@Override
public String toString() {
return "This is MyObject and create time at: " + time;
}
public int getNum() {
return num;
}
public boolean isActive() {
return active;
}
public void setNum(int num) {
this.num = num;
}
public void setActive(boolean active) {
this.active = active;
}
}
3.工厂创建对象
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;
public class MyObjectFactory implements PooledObjectFactory<MyObject> {
@Override
public PooledObject<MyObject> makeObject() throws Exception {
return new DefaultPooledObject<MyObject>(new MyObject());
}
@Override
public void destroyObject(PooledObject<MyObject> pooledObject) throws Exception {
System.out.println("正在销毁对象...");
}
@Override
public boolean validateObject(PooledObject<MyObject> pooledObject) {
System.out.println("正在验证对象...");
return pooledObject.getObject().isActive();
}
@Override
public void activateObject(PooledObject<MyObject> pooledObject) throws Exception {
System.out.println("正在激活对象...");
pooledObject.getObject().setActive(true);
}
@Override
public void passivateObject(PooledObject<MyObject> pooledObject) throws Exception {
System.out.println("正在钝化对象...");
pooledObject.getObject().setActive(false);
}
}
4.测试方法
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
public class Test {
public static void main(String[] args) {
GenericObjectPoolConfig<MyObject> poolConfig = new GenericObjectPoolConfig<>();
poolConfig.setMaxIdle(2);
poolConfig.setMaxTotal(4);
poolConfig.setMinIdle(1);
poolConfig.setMinEvictableIdleTimeMillis(-1);
poolConfig.setTestOnBorrow(true);
poolConfig.setTestOnReturn(false);
GenericObjectPool<MyObject> pool = new GenericObjectPool(new MyObjectFactory(),poolConfig);
MyObject bo = null;
try {
for(int i = 0; i < 5; i++) {
System.out.println("==========="+i+"===========");
System.out.println("池中处于闲置状态的实例pool.getNumIdle()："+pool.getNumIdle());
//从池里取一个对象，有两种选择，新创建或将以前闲置的对象取出来
bo = pool.borrowObject();
System.out.println("bo:" + bo);
System.out.println("池中所有在用实例数量pool.getNumActive()："+pool.getNumActive());
if((i%2) == 0) {
//用完之后归还对象
pool.returnObject(bo);
System.out.println("归还对象！！！！");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
5.运行结果
===========0===========
池中处于闲置状态的实例pool.getNumIdle()：0
New MyObject！！！
正在激活对象...
正在验证对象...
bo:This is MyObject and create time at: 1592904122868
池中所有在用实例数量pool.getNumActive()：1
正在钝化对象...
归还对象！！！！
===========1===========
池中处于闲置状态的实例pool.getNumIdle()：1
正在激活对象...
正在验证对象...
bo:This is MyObject and create time at: 1592904122868
池中所有在用实例数量pool.getNumActive()：1
===========2===========
池中处于闲置状态的实例pool.getNumIdle()：0
New MyObject！！！
正在激活对象...
正在验证对象...
bo:This is MyObject and create time at: 1592904122871
池中所有在用实例数量pool.getNumActive()：2
正在钝化对象...
归还对象！！！！
===========3===========
池中处于闲置状态的实例pool.getNumIdle()：1
正在激活对象...
正在验证对象...
bo:This is MyObject and create time at: 1592904122871
池中所有在用实例数量pool.getNumActive()：2
===========4===========
池中处于闲置状态的实例pool.getNumIdle()：0
New MyObject！！！
正在激活对象...
正在验证对象...
bo:This is MyObject and create time at: 1592904122871
池中所有在用实例数量pool.getNumActive()：3
正在钝化对象...
归还对象！！！！
浙公网安备 33010602011771号