commons-pool2 池化技术探究

时间  2021-04-27
标签 java apache 安全 服务器 并发 框架 异步 ide 源码分析 性能 栏目 Java 繁體版
原文   原文链接

1、前言

咱们常常会接触各类池化的技术或者概念，包括对象池、链接池、线程池等，池化技术最大的好处就是实现对象的重复利用，尤为是建立和使用大对象或者宝贵资源（HTTP链接对象，MySQL链接对象）等方面的时候可以大大节省系统开销，对提高系统总体性能也相当重要。java

在并发请求下，若是须要同时为几百个query操做建立/关闭MySQL的链接或者是为每个HTTP请求建立一个处理线程或者是为每个图片或者XML解析建立一个解析对象而不使用池化技术，将会给系统带来极大的负载挑战。apache

本文主要是分析commons-pool2池化技术的实现方案，但愿经过本文能让读者对commons-pool2的实现原理一个更全面的了解。安全

2、commons-pool2池化技术剖析

愈来愈多的框架在选择使用apache commons-pool2进行池化的管理，如jedis-cluster，commons-pool2工做的逻辑以下图所示：
服务器

2.1 核心三元素

2.1.1 ObjectPool

对象池，负责对对象进行生命周期的管理，并提供了对对象池中活跃对象和空闲对象统计的功能。并发

2.1.2 PooledObjectFactory

对象工厂类，负责具体对象的建立、初始化，对象状态的销毁和验证。commons-pool2框架自己提供了默认的抽象实现BasePooledObjectFactory ，业务方在使用的时候只须要继承该类，而后实现warp和create方法便可。框架

2.1.3 PooledObject

池化对象，是须要放到ObjectPool对象的一个包装类。添加了一些附加的信息，好比说状态信息，建立时间，激活时间等。commons-pool2提供了DefaultPooledObject和 PoolSoftedObject 2种实现。其中PoolSoftedObject继承自DefaultPooledObject，不一样点是使用SoftReference实现了对象的软引用。获取对象的时候使用也是经过SoftReference进行获取。异步

2.2 对象池逻辑分析

2.2.1 对象池接口说明

1）咱们在使用commons-pool2的时候，应用程序获取或释放对象的操做都是基于对象池进行的，对象池核心接口主要包括以下：ide

/**
*向对象池中增长对象实例
*/
void addObject() throws Exception, IllegalStateException,
      UnsupportedOperationException;
/**
* 从对象池中获取对象
*/
T borrowObject() throws Exception, NoSuchElementException,
      IllegalStateException;
/**
* 失效非法的对象
*/
void invalidateObject(T obj) throws Exception;
/**
* 释放对象至对象池
*/
void returnObject(T obj) throws Exception;

除了接口自己以外，对象池还支持对对象的最大数量，保留时间等等进行设置。对象池的核心参数项包括maxTotal，maxIdle，minIdle，maxWaitMillis，testOnBorrow 等。源码分析

2.2.2 对象建立解耦

对象工厂是commons-pool2框架中用于生成对象的核心环节，业务方在使用过程当中须要本身去实现对应的对象工厂实现类，经过工厂模式，实现了对象池与对象的生成与实现过程细节的解耦，每个对象池应该都有对象工厂的成员变量，如此实现对象池自己和对象的生成逻辑解耦。性能

能够经过代码进一步验证咱们的思路：

public GenericObjectPool(final PooledObjectFactory<T> factory) {
      this(factory, new GenericObjectPoolConfig<T>());
  }
  
  public GenericObjectPool(final PooledObjectFactory<T> factory,
                            final GenericObjectPoolConfig<T> 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);
  }
​
  public GenericObjectPool(final PooledObjectFactory<T> factory,
                            final GenericObjectPoolConfig<T> config, final AbandonedConfig abandonedConfig) {
      this(factory, config);
      setAbandonedConfig(abandonedConfig);
  }

能够看到对象池的构造方法，都依赖于对象构造工厂PooledObjectFactory，在生成对象的时候，基于对象池中定义的参数和对象构造工厂来生成。

/**
* 向对象池中增长对象，通常在预加载的时候会使用该功能
*/
@Override
public void addObject() throws Exception {
  assertOpen();
  if (factory == null) {
      throw new IllegalStateException(
              "Cannot add objects without a factory.");
  }
  final PooledObject<T> p = create();
  addIdleObject(p);
}

create() 方法基于对象工厂来生成的对象，继续往下跟进代码来确认逻辑；

final PooledObject<T> p;
try {
  p = factory.makeObject();
  if (getTestOnCreate() && !factory.validateObject(p)) {
      createCount.decrementAndGet();
      return null;
  }
} catch (final Throwable e) {
  createCount.decrementAndGet();
  throw e;
} finally {
  synchronized (makeObjectCountLock) {
      makeObjectCount--;
      makeObjectCountLock.notifyAll();
  }
}

此处确认了factory.makeObject()的操做，也印证了上述的推测，基于对象工厂来生成对应的对象。

为了更好的可以实现对象池中对象的使用以及跟踪对象的状态，commons-pool2框架中使用了池化对象PooledObject的概念，PooledObject自己是泛型类，并提供了getObject()获取实际对象的方法。

2.2.3 对象池源码分析

通过上述分析咱们知道了对象池承载了对象的生命周期的管理，包括整个对象池中对象数量的控制等逻辑，接下来咱们经过GenericObjectPool的源码来分析到底是如何实现的。

对象池中使用了双端队列LinkedBlockingDeque来存储对象，LinkedBlockingDeque对列支持FIFO和FILO两种策略，基于AQS来实现队列的操做的协同。

LinkedBlockingDeque提供了队尾和队头的插入和移除元素的操做，相关操做都进行了加入重入锁的加锁操做队列中设置notFull 和 notEmpty两个状态变量，当对队列进行元素的操做的时候会触发对应的执行await和notify等操做。

/**
* 第一个节点
* Invariant: (first == null && last == null) ||
*           (first.prev == null && first.item != null)
*/
private transient Node<E> first; // @GuardedBy("lock")
​
/**
* 最后一个节点
* Invariant: (first == null && last == null) ||
*           (last.next == null && last.item != null)
*/
private transient Node<E> last; // @GuardedBy("lock")
​
/** 当前队列长度 */
private transient int count; // @GuardedBy("lock")
​
/** 队列最大容量 */
private final int capacity;
​
/** 主锁 */
private final InterruptibleReentrantLock lock;
​
/** 队列是否为空状态锁 */
private final Condition notEmpty;
​
/** 队列是否满状态锁 */
private final Condition notFull;

队列核心点为：

1.队列中全部的移入元素、移出、初始化构造元素都是基于主锁进行加锁操做。

2.队列的offer和pull支持设置超时时间参数，主要是经过两个状态Condition来进行协调操做。如在进行offer操做的时候，若是操做不成功，则基于notFull状态对象进行等待。

public boolean offerFirst(final E e, final long timeout, final TimeUnit unit)
  throws InterruptedException {
  Objects.requireNonNull(e, "e");
  long nanos = unit.toNanos(timeout);
  lock.lockInterruptibly();
  try {
      while (!linkFirst(e)) {
          if (nanos <= 0) {
              return false;
          }
          nanos = notFull.awaitNanos(nanos);
      }
      return true;
  } finally {
      lock.unlock();
  }
}

如进行pull操做的时候，若是操做不成功，则对notEmpty进行等待操做。

public E takeFirst() throws InterruptedException {
  lock.lock();
  try {
      E x;
      while ( (x = unlinkFirst()) == null) {
          notEmpty.await();
      }
      return x;
  } finally {
      lock.unlock();
  }
}

反之当操做成功的时候，则进行唤醒操做，以下所示：

private boolean linkLast(final E e) {
  // assert lock.isHeldByCurrentThread();
  if (count >= capacity) {
      return false;
  }
  final Node<E> l = last;
  final Node<E> x = new Node<>(e, l, null);
  last = x;
  if (first == null) {
      first = x;
  } else {
      l.next = x;
  }
  ++count;
  notEmpty.signal();
  return true;
}

2.3 核心业务流程

2.3.1 池化对象状态变动


上图是PooledObject的状态机图，蓝色表示状态，红色表示与ObjectPool相关的方法.PooledObject的状态为：IDLE、ALLOCATED、RETURNING、ABANDONED、INVALID、EVICTION、EVICTION\_RETURN\_TO_HEAD

全部状态是在PooledObjectState类中定义的，其中一些是暂时未使用的，此处再也不赘述。

2.3.2 对象池browObject过程

第一步、根据配置肯定是否要为标签删除调用removeAbandoned方法。

第二步、尝试获取或建立一个对象，源码过程以下：

//一、尝试从双端队列中获取对象，pollFirst方法是非阻塞方法
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);
        }
    }
}

示意图以下所示：

第三步、调用allocate使状态更改成ALLOCATED状态。

第四步、调用工厂的activateObject来初始化对象，若是发生错误，请调用destroy方法来销毁对象，例如源代码中的六个步骤。

第五步、调用TestFactory的validateObject进行基于TestOnBorrow配置的对象可用性分析，若是不可用，则调用destroy方法销毁对象。3-7步骤的源码过程以下所示：

//修改对象状态
if (!p.allocate()) {
    p = null;
}
if (p != null) {
    try {
        //初始化对象
        factory.activateObject(p);
    } catch (final Exception e) {
        try {
            destroy(p, DestroyMode.NORMAL);
        } catch (final Exception e1) {
        }
 
}
    if (p != null && getTestOnBorrow()) {
        boolean validate = false;
        Throwable validationThrowable = null;
        try {
            //验证对象的可用性状态
            validate = factory.validateObject(p);
        } catch (final Throwable t) {
            PoolUtils.checkRethrow(t);
            validationThrowable = t;
        }
        //对象不可用，验证失败，则进行destroy
        if (!validate) {
            try {
                destroy(p, DestroyMode.NORMAL);
               destroyedByBorrowValidationCount.incrementAndGet();
            } catch (final Exception e) {
                // Ignore - validation failure is more important
            }
 
        }
    }
}

2.3.3 对象池returnObject的过程执行逻辑

第一步、调用markReturningState方法将状态更改成RETURNING。

第二步、基于testOnReturn配置调用PooledObjectFactory的validateObject方法以进行可用性检查。若是检查失败，则调用destroy消耗该对象，而后确保调用idle以确保池中有IDLE状态对象可用，若是没有，则调用create方法建立一个新对象。

第三步、调用PooledObjectFactory的passivateObject方法进行反初始化操做。

第四步、调用deallocate将状态更改成IDLE。

第五步、检测是否已超过最大空闲对象数，若是超过，则销毁当前对象。

第六步、根据LIFO（后进先出）配置将对象放置在队列的开头或结尾。

还原操做队列示意图

2.4 拓展和思考

2.4.1 关于LinkedBlockingDeque的另种实现

上文中分析到commons-pool2中使用了双端队列以及java中的condition来实现队列中对象的管理和不一样线程对对象获取和释放对象操做之间的协调，那是否有其余方案能够实现相似效果呢？答案是确定的。

使用双端队列进行操做，实际上是想将空闲对象和活跃对象进行隔离，本质上将咱们用两个队列来分别存储空闲队列和当前活跃对象，而后再统一使用一个对象锁，也是能够达成相同的目标的，大概的思路以下：

一、双端队列改成两个单向队列分别用于存储空闲的和活跃的对象，队列之间的同步和协调能够经过对象锁的wait和notify完成。

public  class PoolState {
 
protected final List<PooledObject> idleObjects = new ArrayList<>();
protected final List<PooledObject> activeObjects = new ArrayList<>();
 
 
//...
 
}

二、在获取对象时候，本来对双端队列的LIFO或者FIFO变成了从空闲队列idleObjects中获取对象，而后在获取成功并对象状态合法后，将对象添加到活跃对象集合activeObjects 中，若是获取对象须要等待，则PoolState对象锁应该经过wait操做，进入等待状态。

三、在释放对象的时候，则首先从活跃对象集合activeObjects 删除元素，删除完成后，将对象增长到空闲对象集合idleObjects中，须要注意的是，在释放对象过程当中也须要去校验对象的状态。当对象状态不合法的时候，对象应该进行销毁，不该该添加到idleObjects中。释放成功后则PoolState经过notify或者notifyAll唤醒等待中的获取操做。

四、为保障对活跃队列和空闲队列的操做线程安全性，获取对象和释放对象须要进行加锁操做，和commons2-pool中的一致。

2.4.2 对象池的自我保护机制

咱们在使用commons-pool2中获取对象的时候，会从双端队列中阻塞等待获取元素(或者是建立新对象)，可是若是是应用程序的异常，一直未调用returnObject或者invalidObject的时候，那可能就会出现对象池中的对象一直上升，到达设置的上线以后再去调用borrowObject的时候就会出现一直等待或者是等待超时而没法获取对象的状况。

commons-pool2为了不上述分析的问题的出现，提供了两种自我保护机制：

2.4.2.1 基于阈值的检测

从对象池中获取对象的时候会校验当前对象池的活跃对象和空闲对象的数量占比，当空闲独享很是少，活跃对象很是多的时候，会触发空闲对象的回收，具体校验规则为：若是当前对象池中少于2个idle状态的对象或者 active数量>最大对象数-3 的时候，在borrow对象的时候启动泄漏清理。经过AbandonedConfig.setRemoveAbandonedOnBorrow 为 true 进行开启。

//根据配置肯定是否要为标签删除调用removeAbandoned方法
final AbandonedConfig ac = this.abandonedConfig;
if (ac != null && ac.getRemoveAbandonedOnBorrow() && (getNumIdle() < 2) && (getNumActive() > getMaxTotal() - 3) ) {
    removeAbandoned(ac);
}

2.4.2.2 异步调度线程检测

AbandonedConfig.setRemoveAbandonedOnMaintenance 设置为 true 之后，在维护任务运行的时候会进行泄漏对象的清理，经过设置setTimeBetweenEvictionRunsMillis 来设置维护任务执行的时间间隔。

异步检测线程Evictor时序图
检测和回收实现逻辑分析：

在构造方法内部逻辑的最后调用了startEvictor方法。这个方法的做用是在构造完对象池后，启动回收器来监控回收空闲对象。startEvictor定义在GenericObjectPool的父类BaseGenericObjectPool（抽象）类中，咱们先看一下这个方法的源码。

在构造器中会执行以下的设置参数；

public final void setTimeBetweenEvictionRunsMillis(
      final long timeBetweenEvictionRunsMillis) {
  this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
  startEvictor(timeBetweenEvictionRunsMillis);
}

当且仅当设置了timeBetweenEvictionRunsMillis参数后才会开启定时清理任务。

final void startEvictor(final long delay) {
  synchronized (evictionLock) {
      EvictionTimer.cancel(evictor, evictorShutdownTimeoutMillis, TimeUnit.MILLISECONDS);
      evictor = null;
      evictionIterator = null;
      //若是delay<=0则不会开启定时清理任务
      if (delay > 0) {
          evictor = new Evictor();
          EvictionTimer.schedule(evictor, delay, delay);
      }
  }
}

继续跟进代码能够发现，调度器中设置的清理方法的实现逻辑实际在对象池中定义的，也就是由GenericObjectPool或者GenericKeyedObjectPool来实现，接下来咱们继续探究对象池是如何进行对象回收的。

a)、核心参数：

minEvictableIdleTimeMillis：指定空闲对象最大保留时间，超过此时间的会被回收。不配置则不过时回收。

softMinEvictableIdleTimeMillis：一个毫秒数值，用来指定在空闲对象数量超过minIdle设置，且某个空闲对象超过这个空闲时间的才能够会被回收。

minIdle：对象池里要保留的最小空间对象数量。

b)、回收逻辑

以及一个对象回收策略接口EvictionPolicy，能够预料到对象池的回收会和上述的参数项及接口EvictionPolicy发生关联，继续跟进代码会发现以下的内容，能够看到在判断对象池能够进行回收的时候，直接调用了destroy进行回收。

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进行回收
    destroy(underTest);
    destroyedByEvictorCount.incrementAndGet();
}

为提高回收的效率，在回收策略判断对象的状态不是evict的时候，也会进行进一步的状态判断和处理，具体逻辑以下：

1.尝试激活对象，若是激活失败则认为对象已经再也不存活，直接调用destroy进行销毁。

2.在激活对象成功的状况下，会经过validateObject方法取校验对象状态，若是校验失败，则说明对象不可用，须要进行销毁。

boolean active = false;
try {
  // 调用activateObject激活该空闲对象，本质上不是为了激活，
  // 而是经过这个方法能够断定是否还存活，这一步里面可能会有一些资源的开辟行为。
  factory.activateObject(underTest);
  active = true;
} catch (final Exception e) {
  // 若是激活的时候，发生了异常，就说明该空闲对象已经失联了。
  // 调用destroy方法销毁underTest
  destroy(underTest);
  destroyedByEvictorCount.incrementAndGet();
}
if (active) {
  // 再经过进行validateObject校验有效性
  if (!factory.validateObject(underTest)) {
      // 若是校验失败，说明对象已经不可用了
      destroy(underTest);
      destroyedByEvictorCount.incrementAndGet();
  } else {
      try {
          /*
            *由于校验还激活了空闲对象，分配了额外的资源，那么就经过passivateObject把在activateObject中开辟的资源释放掉。
          */
          factory.passivateObject(underTest);
      } catch (final Exception e) {
          // 若是passivateObject失败，也能够说明underTest这个空闲对象不可用了
          destroy(underTest);
          destroyedByEvictorCount.incrementAndGet();
      }
  }
}

3、写在最后

链接池可以给程序开发者带来一些便利性，前言中咱们分析了使用池化技术的好处和必要性，可是咱们也能够看到commons-pool2框架在对象的建立和获取上都进行了加锁的操做，这会在并发场景下必定程度的影响应用程序的性能，其次池化对象的对象池中对象的数量也是须要进行合理的设置，不然也很难起到真正的使用对象池的目的，这给咱们也带来了必定的挑战。

做者：vivo 互联网服务器团队-Huang Xiaoqun
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程