标签：and execution commons tween ide effect 移除 think jar包
转载请注明源出处：http://www.cnblogs.com/lighten/p/7375611.html
本章介绍一下常用基础Jar包commons-pools2，最近使用到了thrift作为rpc服务通讯，但是没有找到其提供的连接池。百度了一下官方貌似没有提供，需要自己实现，所以根据网上的实现方法通过使用commons-pool2包来构建自己的thrift连接池服务。完成后，顺便研究了一下commons-pool2的实现(怕使用不当有坑)，也就有了这篇文章。
既然名字中有个2也就意味着是第二个版本了，重新命名也就意味着和原版本并不兼容。这是apache提供的一个开源包，在很多地方都会使用，2015年7月之后就不再进行更新了，目前最新版本是2.4.2(最近突然又更新了目前在2.5.0版本)。其准确来说应该是一个对象池，不过是常用在于连接上而已。
commons-pool2的类并不多，全部42个类如下：
包的结构简单，类不多，而且还有大量的接口和内部类，所以实际上需要关注的类没几个，commons-pool2使用起来也就方便了。
上面也说了，该类是一个基础包，被很多其它jar包使用，常用于对象池的管理，所以其一些配置，在写代码的时候也会经常接触到类似的，可能是封装过的，也可能是版本1的，不过大同小异，主要是思路。了解了配置的具体作用，再结合代码就能够了解这类jar包是如何写的了。
通用的配置都在GenericObjectPoolConfig类中：
maxTotal：对象池中最多允许的对象数，默认8（可能超过，不过超过后使用完了就会销毁，后面源码会介绍相关机制）
maxIdle：对象池中最多允许存在的空闲对象，默认8
minIdle：池中最少要保留的对象数，默认0
lifo：是否使用FIFO先进先出的模式获取对象（空闲对象都在一个队列中），默认为true使用先进先出，false是先进后出
fairness：是否使用公平锁，默认false(公平锁是线程安全中的概念，true的含义是谁先等待获取锁，随先在锁释放的时候获取锁，如非必要，一般不使用公平锁，会影响性能)
maxWaitMillis：从池中获取一个对象最长的等待时间，默认-1，含义是无限等，超过这个时间还未获取空闲对象，就会抛出异常。
minEvictableIdleTimeMillis：最小的驱逐时间，单位毫秒，默认30分钟。这个用于驱逐线程，对象空闲时间超过这个时间，意味着此时系统不忙碌，会减少对象数量。
evictorShutdownTimeoutMillis：驱逐线程关闭的超时时间，默认10秒。
softMinEvictableIdleTimeMillis：也是最小的驱逐时间，但是会和另一个指标minIdle一同使用，满足空闲时间超过这个设置，且当前空闲数量比设置的minIdle要大，会销毁该对象。所以，通常该值设置的比minEvictableIdleTimeMillis要小。
numTestsPerEvictionRun：驱逐线程运行每次测试的对象数量，默认3个。驱逐线程就是用来检查对象空闲状态，通过设置的对象数量等参数，保持对象的活跃度和数量，其是一个定时任务，每次不是检查所有的对象，而是抽查几个，这个就是用于抽查。
evictionPolicyClassName：驱逐线程使用的策略类名，之前的minEvictableIdleTimeMillis和softMinEvictableIdleTimeMillis就是默认策略DefaultEvictionPolicy的实现，可以自己实现策略。
testOnCreate：在创建对象的时候是否检测对象，默认false。后续会结合代码说明是如何检测的。
testOnBorrow：在获取空闲对象的时候是否检测对象是否有效，默认false。这个通常会设置成true，一般希望获取一个可用有效的对象吧。
testOnReturn：在使用完对象放回池中时是否检测对象是否仍有效，默认false。
testWhileIdle：在空闲的时候是否检测对象是否有效，这个发生在驱逐线程执行时。
timeBetweenEvictionRunsMillis：驱逐线程的执行周期，上面说过该线程是个定时任务。默认-1，即不开启驱逐线程，所以与之相关的参数是没有作用的。
blockWhenExhausted：在对象池耗尽时是否阻塞，默认true。false的话超时就没有作用了。
jmxEnabled：是否允许jmx的方式创建一个配置实例，默认true。
jmxNamePrefix：jmx默认的前缀名，默认为pool
jmxNameBase：jmx默认的base name，默认为null，意味着池提供一个名称。
上面的配置已经说明了一些内容了，此节介绍对象池的一个基础实现思路。
首先作为一个对象池，我们需要从池中借对象，借完了要还，还要能创建对象存入池中，校验对象是否还能使用。这个就是一个对象池的基本定义了：
commons-pool2还提供了一种控制细粒度更高的对象池KeyedObjectPool<K,V>。其根据关键字来维护不同的池，在某些场景十分有用，这里不对其做详细介绍，弄明白了一般的线程池，对这种池扩展也就有了思路。从接口到抽象类到具体实现类池经历了下面几个类：ObjectPool->BaseObjectPool->SoftReferenceObjectPool，这种用的比较少，看名次也知道是软引用的池，另一种是BaseGenericObjectPool->GenericObjectPool。通常我们会继承GenericObjectPool来设计自己的对象池。
有了池之后，我们需要一个创建池对象的类，这个就是工厂类：PooledObjectFactory。其要提供一个对象的生命周期的各个操作，包括创建、销毁、校验有效性、激活和钝化对象。
同样，其提供了一个抽象类BasePooledObjectFactory，这个就没有具体的实现类了，因为涉及到不同对象，不同对象的管理方法不同，不好抽象。我们需要做的就是继承BasePooledObjectFactory对象，实现其未实现或者空实现的方法了，即上述截图的方法。
有了池来管理对象使用，有了工厂来管理对象的生命周期，一般而言也就够了。但是还有一个重要的环节就是将池与工厂连接起来的对象的定义，所以要进行抽象。这就是PooledObject的作用了，其定义的一系列方法，将我们的对象和池以及工厂，通过这个接口关联了起来。实现类是DefaultPooledObject，通常使用这个就够了，不需要扩展。如果业务上对对象有更细致的控制，可以继承或者直接自己实现PooledObject。
到此也就剩下一个驱逐线程没介绍了，其维持着池的健康，或者说是活力。以上就是一个对象池的基本内容：池本身，创建对象的工厂，清洁池的驱逐线程，关联池和工厂和自己创建的对象的池对象规范。这样也就没几个类没介绍过了，剩下的就是UsageTracking，看名称也能知道是干啥的了，后面介绍详细流程的时候会顺带一提，用的不多。
下面结合具体代码构建一个对象池，来说明该池的是怎么工作的。首先该对象的基本定义如下：需要一个对象类型Student，需要一个连接池管理对象CommonObjectPool，需要一个制造对象的工厂StudentFactory。其大体代码如下：
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name=‘" + name + ‘\‘‘ +
", age=" + age +
‘}‘;
}
}
public class StudentFactory extends BasePooledObjectFactory<Student> {
private Random random = new Random();
public Student create() throws Exception {
int age = random.nextInt(100);
Student student = new Student("commons", age);
System.out.println("创建对象:" + student);
return student;
}
public PooledObject<Student> wrap(Student obj) {
return new DefaultPooledObject<Student>(obj);
}
@Override
public void destroyObject(PooledObject<Student> p) throws Exception {
System.out.println("销毁对象：" + p.getObject());
super.destroyObject(p);
}
@Override
public boolean validateObject(PooledObject<Student> p) {
System.out.println("校验对象是否可用：" + p.getObject());
return super.validateObject(p);
}
@Override
public void activateObject(PooledObject<Student> p) throws Exception {
System.out.println("激活钝化的对象系列操作：" + p.getObject());
super.activateObject(p);
}
@Override
public void passivateObject(PooledObject<Student> p) throws Exception {
System.out.println("钝化未使用的对象：" + p.getObject());
super.passivateObject(p);
}
}
public class CommonObjectPool extends GenericObjectPool<Student> {
public CommonObjectPool(PooledObjectFactory<Student> factory, GenericObjectPoolConfig config, AbandonedConfig abandonedConfig) {
super(factory, config, abandonedConfig);
}
}
使用方法如下：
public class Test {
public static void main(String[] args) {
StudentFactory studentFactory = new StudentFactory();
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
AbandonedConfig abandonedConfig = new AbandonedConfig();
CommonObjectPool pool = new CommonObjectPool(studentFactory, config, abandonedConfig);
Student student = null;
try {
student = pool.borrowObject();
System.out.println(student);
} catch (Exception e) {
e.printStackTrace();
} finally {
if(student != null) pool.returnObject(student);
}
}
}
下面结合源码和例子讲解执行过程，先是通过对象工厂类和配置初始化了一个pool，pool的初始化操作代码如下：
public GenericObjectPool(final PooledObjectFactory<T> factory,
final GenericObjectPoolConfig config) {
super(config, ONAME_BASE, config.getJmxNamePrefix());
if (factory == null) {
jmxUnregister(); // tidy up
throw new IllegalArgumentException("factory may not be null");
}
this.factory = factory;
idleObjects = new LinkedBlockingDeque<>(config.getFairness());
setConfig(config);
startEvictor(getTimeBetweenEvictionRunsMillis());
}
主要的工作就是设置工厂类，配置，开启驱逐线程。下面先介绍驱逐线程的工作机制：
final void startEvictor(final long delay) {
synchronized (evictionLock) {
if (null != evictor) {
EvictionTimer.cancel(evictor, evictorShutdownTimeoutMillis, TimeUnit.MILLISECONDS);
evictor = null;
evictionIterator = null;
}
if (delay > 0) {
evictor = new Evictor();
EvictionTimer.schedule(evictor, delay, delay);
}
}
}
如果设置过了就会关闭，不然要delay大于0才会开启该线程，该值就是config中的getTimeBetweenEvictionRunsMillis。开启方式就是通过EvictionTimer的周期任务，这实际上就是一个Timer定时器。该定时器做的工作如下：
public void run() {
final ClassLoader savedClassLoader =
Thread.currentThread().getContextClassLoader();
try {
if (factoryClassLoader != null) {
// Set the class loader for the factory
final ClassLoader cl = factoryClassLoader.get();
if (cl == null) {
// The pool has been dereferenced and the class loader
// GC‘d. Cancel this timer so the pool can be GC‘d as
// well.
cancel();
return;
}
Thread.currentThread().setContextClassLoader(cl);
}
// Evict from the pool
try {
evict();
} catch(final Exception e) {
swallowException(e);
} catch(final OutOfMemoryError oome) {
// Log problem but give evictor thread a chance to continue
// in case error is recoverable
oome.printStackTrace(System.err);
}
// Re-create idle instances.
try {
ensureMinIdle();
} catch (final Exception e) {
swallowException(e);
}
} finally {
// Restore the previous CCL
Thread.currentThread().setContextClassLoader(savedClassLoader);
}
}
可以看出，先进行了驱逐，再判断是否小于minIdle的设置，小于就会再次创建对象。
private void ensureIdle(final int idleCount, final boolean always) throws Exception {
if (idleCount < 1 || isClosed() || (!always && !idleObjects.hasTakeWaiters())) {
return;
}
while (idleObjects.size() < idleCount) {
final PooledObject<T> p = create();
if (p == null) {
// Can‘t create objects, no reason to think another call to
// create will work. Give up.
break;
}
if (getLifo()) {
idleObjects.addFirst(p);
} else {
idleObjects.addLast(p);
}
}
if (isClosed()) {
// Pool closed while object was being added to idle objects.
// Make sure the returned object is destroyed rather than left
// in the idle object pool (which would effectively be a leak)
clear();
}
}
就是调用create方法创建，根据lifo的参数决定是先入先出还是后入先出。evict方法主要做了如下操作：
public void evict() throws Exception {
assertOpen();
if (idleObjects.size() > 0) {
PooledObject<T> underTest = null;
final EvictionPolicy<T> evictionPolicy = getEvictionPolicy();
synchronized (evictionLock) {
final EvictionConfig evictionConfig = new EvictionConfig(
getMinEvictableIdleTimeMillis(),
getSoftMinEvictableIdleTimeMillis(),
getMinIdle());
final boolean testWhileIdle = getTestWhileIdle();
for (int i = 0, m = getNumTests(); i < m; i++) {
if (evictionIterator == null || !evictionIterator.hasNext()) {
evictionIterator = new EvictionIterator(idleObjects);
}
if (!evictionIterator.hasNext()) {
// Pool exhausted, nothing to do here
return;
}
try {
underTest = evictionIterator.next();
} catch (final NoSuchElementException nsee) {
// Object was borrowed in another thread
// Don‘t count this as an eviction test so reduce i;
i--;
evictionIterator = null;
continue;
}
if (!underTest.startEvictionTest()) {
// Object was borrowed in another thread
// Don‘t count this as an eviction test so reduce i;
i--;
continue;
}
// User provided eviction policy could throw all sorts of
// crazy exceptions. Protect against such an exception
// killing the eviction thread.
boolean evict;
try {
evict = evictionPolicy.evict(evictionConfig, underTest,
idleObjects.size());
} catch (final Throwable t) {
// Slightly convoluted as SwallowedExceptionListener
// uses Exception rather than Throwable
PoolUtils.checkRethrow(t);
swallowException(new Exception(t));
// Don‘t evict on error conditions
evict = false;
}
if (evict) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
} else {
if (testWhileIdle) {
boolean active = false;
try {
factory.activateObject(underTest);
active = true;
} catch (final Exception e) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
}
if (active) {
if (!factory.validateObject(underTest)) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
} else {
try {
factory.passivateObject(underTest);
} catch (final Exception e) {
destroy(underTest);
destroyedByEvictorCount.incrementAndGet();
}
}
}
}
if (!underTest.endEvictionTest(idleObjects)) {
// TODO - May need to add code here once additional
// states are used
}
}
}
}
}
final AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getRemoveAbandonedOnMaintenance()) {
removeAbandoned(ac);
}
}
先是判断池是开启状态，且空闲对象要大于0，不然不需要驱逐。然后循环了设置的numTests的次数，一次驱逐就检查这么多个对象。后面一段是并发被干扰的一些操作，主要是保证被干扰后仍检查这么些对象。最后就是根据驱逐策略来驱逐对象。上面配置项说过是怎么回事，具体见DefaultEvictionPolicy。如果判断是驱逐，就调用destory方法销毁对象。否则，判断testWhileIdle配置项，决定是否校验对象是否仍可用，先激活对象activateObject，有异常直接销毁。否则开始校验对象的可用性，validateObject。失败销毁，成功就钝化变成原样子。钝化失败也直接销毁。最后是一个遗弃对象的设置，就是说有些对象借出去了由于种种原因，比如写法上的问题，导致对象很久没有还回来，这个设置就是用于清理这类对象的。这类对象不再被池借出，但又暂用了资源。一般而言该配置很少用到，因为写方式通常都将return操作放在finally模块，不会出现此类情况。
最后我们看下借对象和还对象都做了哪些操作吧。
public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
assertOpen();
final AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
(getNumIdle() < 2) &&
(getNumActive() > getMaxTotal() - 3) ) {
removeAbandoned(ac);
}
PooledObject<T> p = null;
// Get local copy of current config so it is consistent for entire
// method execution
final boolean blockWhenExhausted = getBlockWhenExhausted();
boolean create;
final long waitTime = System.currentTimeMillis();
while (p == null) {
create = false;
p = idleObjects.pollFirst();
if (p == null) {
p = create();
if (p != null) {
create = true;
}
}
if (blockWhenExhausted) {
if (p == null) {
if (borrowMaxWaitMillis < 0) {
p = idleObjects.takeFirst();
} else {
p = idleObjects.pollFirst(borrowMaxWaitMillis,
TimeUnit.MILLISECONDS);
}
}
if (p == null) {
throw new NoSuchElementException(
"Timeout waiting for idle object");
}
} else {
if (p == null) {
throw new NoSuchElementException("Pool exhausted");
}
}
if (!p.allocate()) {
p = null;
}
if (p != null) {
try {
factory.activateObject(p);
} catch (final Exception e) {
try {
destroy(p);
} catch (final Exception e1) {
// Ignore - activation failure is more important
}
p = null;
if (create) {
final NoSuchElementException nsee = new NoSuchElementException(
"Unable to activate object");
nsee.initCause(e);
throw nsee;
}
}
if (p != null && (getTestOnBorrow() || create && getTestOnCreate())) {
boolean validate = false;
Throwable validationThrowable = null;
try {
validate = factory.validateObject(p);
} catch (final Throwable t) {
PoolUtils.checkRethrow(t);
validationThrowable = t;
}
if (!validate) {
try {
destroy(p);
destroyedByBorrowValidationCount.incrementAndGet();
} catch (final Exception e) {
// Ignore - validation failure is more important
}
p = null;
if (create) {
final NoSuchElementException nsee = new NoSuchElementException(
"Unable to validate object");
nsee.initCause(validationThrowable);
throw nsee;
}
}
}
}
}
updateStatsBorrow(p, System.currentTimeMillis() - waitTime);
return p.getObject();
}
借的操作步骤如下：先确定池是否开启，再根据条件决定是否移除遗弃的对象。开始获取对象：1.从idle中获取一个，没获取到就创建一个，创建的逻辑涉及参数maxTotal，超过这个值不会创建对象，返回null，maxTotal为-1意为创建的数量为无限（整数最大）。2.创建失败，线程阻塞，等待时间为-1就一直等待，不为-1等到指定时间还没等到，就抛出异常。3.不等待直接会在没获取对象的时候直接抛出异常。4.对象状态不对，没有锁定，置为null。5.上述都没问题，获取对象后开始激活对象，失败销毁对象。成功后判断是否borrow和create的时候要校验对象可用性，需要进行校验，校验失败销毁。上诉是一个while(p==null)的循环，所以borrow的结果只有2种，1是借不到对象超时，2是借到对象。其他就是等待获取空闲对象。
还对象的逻辑也不难：
public void returnObject(final T obj) {
final PooledObject<T> p = allObjects.get(new IdentityWrapper<>(obj));
if (p == null) {
if (!isAbandonedConfig()) {
throw new IllegalStateException(
"Returned object not currently part of this pool");
}
return; // Object was abandoned and removed
}
synchronized(p) {
final PooledObjectState state = p.getState();
if (state != PooledObjectState.ALLOCATED) {
throw new IllegalStateException(
"Object has already been returned to this pool or is invalid");
}
p.markReturning(); // Keep from being marked abandoned
}
final long activeTime = p.getActiveTimeMillis();
if (getTestOnReturn()) {
if (!factory.validateObject(p)) {
try {
destroy(p);
} catch (final Exception e) {
swallowException(e);
}
try {
ensureIdle(1, false);
} catch (final Exception e) {
swallowException(e);
}
updateStatsReturn(activeTime);
return;
}
}
try {
factory.passivateObject(p);
} catch (final Exception e1) {
swallowException(e1);
try {
destroy(p);
} catch (final Exception e) {
swallowException(e);
}
try {
ensureIdle(1, false);
} catch (final Exception e) {
swallowException(e);
}
updateStatsReturn(activeTime);
return;
}
if (!p.deallocate()) {
throw new IllegalStateException(
"Object has already been returned to this pool or is invalid");
}
final int maxIdleSave = getMaxIdle();
if (isClosed() || maxIdleSave > -1 && maxIdleSave <= idleObjects.size()) {
try {
destroy(p);
} catch (final Exception e) {
swallowException(e);
}
} else {
if (getLifo()) {
idleObjects.addFirst(p);
} else {
idleObjects.addLast(p);
}
if (isClosed()) {
// Pool closed while object was being added to idle objects.
// Make sure the returned object is destroyed rather than left
// in the idle object pool (which would effectively be a leak)
clear();
}
}
updateStatsReturn(activeTime);
}
更新对象状态，判断还的时候是否要校验对象可用性，不可用销毁。之后钝化对象，钝化失败销毁，超过maxIdle也直接销毁。最后根据lifo来确定放回方式。因为涉及销毁对象，所以都要进行确定minidle来决定是否补充对象。
commons-pool2的主要逻辑就是上述内容了，代码例子也给了一个。这里总结一下对象的一个生命周期：create->activate->invalidate->borrow->invalidate->return->destory。其中validate阶段发生在各个环节，主要通过TestOnXXX进行配置决定。
标签：and execution commons tween ide effect 移除 think jar包
原文地址：https://www.cnblogs.com/lighten/p/7375611.html
