"Redis客户端连接数一直降不下来"的有关问题解决 good

[线上问题] "Redis客户端连接数一直降不下来"的问题解决

前段时间，上线了新的 Redis缓存（Cache）服务，准备替换掉 Memcached。

 

为什么要将 Memcached 替换掉？

原因是 业务数据是压缩后的列表型数据，缓存中保存最新的3000条数据。对于新数据追加操作，需要拆解成[get + unzip + append + zip + set]这5步操作。若列表长度在O(1k)级别的，其耗时至少在50ms+。而在并发环境下，这样会存在“数据更新覆盖问题”，因为追加操作不是原子操作。（线上也确实遇到了这个问题）

 

针对“追加操作不是原子操作”的问题，我们就开始调研有哪些可以解决这个问题同时又满足业务数据类型的分布式缓存解决方案。

当前，业界常用的一些 key-value分布式缓存系统如下：

• Redis
• Memcached
• Cassandra
• Tokyo Tyrant (Tokyo Cabinet)

参考自：

• 2010年的技术架构建议 – Tim Yang
• From distributed caches to in-memory data grids
• Cassandra vs MongoDB vs CouchDB vs Redis vs Riak vs HBase vs Couchbase vs OrientDB vs Aerospike vs Hypertable vs ElasticSearch vs Accumulo vs VoltDB vs Scalaris comparison

通过对比、筛选分析，我们最终选择了 Redis。原因有以下几个：

• Redis 是一个 key-value 的缓存(cache)和存储(store)系统（现在我们只用它来做缓存，目前还未当作DB用，数据存放在 Cassandra 里）
• 支持丰富的数据结构，List 就专门用于存储列表型数据，默认按操作时间排序。Sorted Set 可以按分数排序元素，分数是一种广义概念，可以是时间或评分。其次，其丰富的数据结构为日后扩展提供了很大的方便。
• 提供的所有操作都是原子操作，为并发天然保驾护航。
• 超快的性能，见其官方性能测试《How fast is Redis?》。
• 拥有比较成熟的Java客户端 - Jedis，像新浪微博都是使用它作为客户端。（官方推荐的Clients）

啰嗦了一些其它东西，现在言归正传。

 

Redis 服务上线当天，就密切关注 Redis 的一些重要监控指标（clients：客户端连接数、memory、stats：服务器每秒钟执行的命令数量、commandstats：一些关键命令的执行统计信息、redis.error.log：异常日志）。（参考自《Redis监控方案》）

 

观察到下午5点左右，发现“客户端连接数”一直在增长，最高时都超过了2000个（见下图），即使减少也就减1~2个。但应用的QPS却在 10 个左右，而线上应用服务器不超过10台。按理说，服务器肯定不会有这么高的连接数，肯定哪里使用有问题。

 

 

现在只能通过逆向思维反向来推测问题：

• Redis服务端监控到的“客户端连接数”表明所有客户端总和起来应该有那么多，所以首先到各个应用服务器上确认连接数量；
• 通过“sudo netstat -antp | grep 6379 | wc -l”确认，有一台应用Redis的连接数都超过了1000个，另一台应用则在400左右，其它的都在60上下。（60上下是正常的）
• 第一个问题：为什么不同的机器部署了同一个应用程序，表现出来的行为却是不一样？
• 第二个问题：连接数超过1000个的那台，其请求量(140)是比其它机器(200+)要低的(因为它在Nginx中配置的权重低)，那它的连接数为什么会这么高？到底发生了什么？
• 对于“第二个问题”，我们通过各个应用的Redis异常日志（redis.error.log）知道发生了什么。最高那台应用的异常操作特别多，共有130+个异常，且存在“关闭集群链接时异常导致连接泄漏”问题；另一台较高的应用也存在类似的情况，而其它正常的应用则不超过2个异常，且不存在“连接泄漏”问题。这样，“第二个问题”算是弄清楚了。（“连接泄漏”问题具体如何修复见《[FAQ] Jedis使用过程中踩过的那些坑》）
• 至此，感觉问题好像已经解决了，但其实没有。通过连续几天的观察，发现最高的时候，它的连接数甚至超过了3000+，这太恐怖了。（当时 leader 还和我说，要不要重启一下应用）
• 即使应用的QPS是 20个/s，且存在“连接泄漏”问题，连接数也不会超过1000+。但现在连接数居然达到了3000+，这说不通，只有一个可能就是未正确使用Jedis。
• 这时候就继续反推，Redis的连接数反映了Jedis对象池的池对象数量。线上部署了2台Redis服务器作为一个集群，说明这台应用共持有(3000/2=1500)个池对象。(因为Jedis基于Apache Commons Pool的GenericObjectPool实现)
• 第三个问题：根据应用的QPS，每秒钟请求需要的Active池对象也不会超过20个，那其余的1480个都是“空闲池对象”。为什么那么多的“空闲池对象”未被释放？
• 现在就来反思：Jedis的那些配置属性与对象池管理“空闲池对象”相关，GenericObjectPool背后是怎么管理“空闲池对象”的？

由于在使用Jedis的过程中，就对Apache Commons Pool摸了一次底。对最后的两个疑惑都比较了解，Jedis的以下这些配置与对象池管理“空闲池对象”相关：

redis.max.idle.num=32768
redis.min.idle.num=30
redis.pool.behaviour=FIFO
redis.time.between.eviction.runs.seconds=1
redis.num.tests.per.eviction.run=10
redis.min.evictable.idle.time.minutes=5
redis.max.evictable.idle.time.minutes=1440

 

在上面说“每台应用的Jedis连接数在60个左右是正常的”的理由是：线上共部署了2台Redis服务器，Jedis的“最小空闲池对象个数”配置为30 (redis.min.idle.num=30)。

 

GenericObjectPool是通过“驱逐者线程Evictor”管理“空闲池对象”的，详见《Apache Commons Pool之空闲对象的驱逐检测机制》一文。最下方的5个配置都是与“驱逐者线程Evictor”相关的，表示对象池的空闲队列行为为FIFO“先进先出”队列方式，每秒钟(1)检测10个空闲池对象，空闲池对象的空闲时间只有超过5分钟后，才有资格被驱逐检测，若空闲时间超过一天(1440)，将被强制驱逐。

 

因为“驱逐者线程Evictor”会无限制循环地对“池对象空闲队列”进行迭代式地驱逐检测。空闲队列的行为有两种方式：LIFO“后进先出”栈方式、FIFO“先进先出”队列方式，默认使用LIFO。下面通过两幅图来展示这两种方式的实际运作方式：

   一、LIFO“后进先出”栈方式

 

二、FIFO“先进先出”队列方式

从上面这两幅图可以看出，LIFO“后进先出”栈方式 有效地利用了空闲队列里的热点池对象资源，随着流量的下降会使一些池对象长时间未被使用而空闲着，最终它们将被淘汰驱逐；
而 FIFO“先进先出”队列方式 虽然使空闲队列里所有池对象都能在一段时间里被使用，看起来它好像分散了资源的请求，但其实这不利于资源的释放(因为空闲池对象的空闲时间只有超过5分钟后，才有资格被驱逐检测，分散资源请求的同时，也导致符合释放条件的空闲对象也变少了，而每个空闲对象都占用一个redis连接)。
而这也是“客户端连接数一直降不下来”的根源之一。

redis.pool.behaviour=FIFO
redis.time.between.eviction.runs.seconds=1
redis.num.tests.per.eviction.run=10
redis.min.evictable.idle.time.minutes=5

按照上述配置，我们可以计算一下，5分钟里到底有多少个空闲池对象被循环地使用过。
根据应用QPS 10个/s计算，5分钟里大概有10*5*60=3000个空闲池对象被使用过，正好与上面的“连接数尽然达到了3000+”符合，这样就说得通了。至此，整个问题终于水落石出了。（从监控图也可以看出，在21号晚上6点左右修改配置重启服务后，连接数就比较平稳了）

 

这里还要解释一下为什么使用FIFO“先进先出”队列方式的空闲队列行为？

因为我们在Jedis的基础上开发了“故障节点自动摘除，恢复正常的节点自动添加”的功能，本来想使用FIFO“先进先出”队列方式在节点故障时，对象池能快速更新整个集群信息，没想到弄巧成拙了。

修复后的Jedis配置如下：

redis.max.idle.num=32768
redis.min.idle.num=30
redis.pool.behaviour=LIFO
redis.time.between.eviction.runs.seconds=1
redis.num.tests.per.eviction.run=10
redis.min.evictable.idle.time.minutes=5
redis.max.evictable.idle.time.minutes=30

 

综上所述，这个问题发生有两方面的原因：

1. 未正确使用对象池的空闲队列行为（LIFO“后进先出”栈方式）
2. “关闭集群链接时异常导致连接泄漏”问题

 

http://www.myexception.cn/internet/1849994.html

 

本文主要剖析 Apache Commons Pool 的“空闲对象的驱逐检测机制”的实现原理。

 

以下面3个步骤来循序渐进地深入剖析其实现原理：

1. 启动“空闲对象的驱逐者线程”（startEvictor(...)）的2个入口
2. 在启动时，创建一个新的"驱逐者线程"(Evictor)，并使用"驱逐者定时器"(EvictionTimer)进行调度
3. 进入真正地"空闲池对象"的驱逐检测操作（evict()）

下图是“空闲对象的驱逐检测机制”处理流程的时序图(阅读代码时结合着看可以加深理解)：

GenericObjectPool.evict() 处理流程的时序图：

GenericObjectPool.ensureMinIdle()处理流程的时序图：

 

一、启动“空闲对象的驱逐者线程”（startEvictor(...)）共有2个入口

1. GenericObjectPool 构造方法

GenericObjectPool(...)：初始化"池对象工厂"，设置"对象池配置"，并启动"驱逐者线程"。

/**
 * 使用特定的配置来创建一个新的"通用对象池"实例。
 *
 * @param factory   The object factory to be used to create object instances
 *                  used by this pool (用于创建池对象实例的对象工厂)
 * @param config    The configuration to use for this pool instance. (用于该对象池实例的配置信息)
 *                  The configuration is used by value. Subsequent changes to
 *                  the configuration object will not be reflected in the
 *                  pool. (随后对配置对象的更改将不会反映到池中)
 */
public GenericObjectPool(PooledObjectFactory<T> factory,
        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;

    this.setConfig(config);
    // 启动"驱逐者线程"
    startEvictor(this.getTimeBetweenEvictionRunsMillis());
}

 

2. BaseGenericObjectPool.setTimeBetweenEvictionRunsMillis(...) - 设置"驱逐者线程"的运行间隔时间

可以动态地更新"驱逐者线程"的运行调度间隔时间。

/**
 * 设置"空闲对象的驱逐者线程"的运行调度间隔时间。（同时，会立即启动"驱逐者线程"）
 * <p>
 * 如果该值是非正数，则没有"空闲对象的驱逐者线程"将运行。
 * <p>
 * 默认是 {@code -1}，即没有"空闲对象的驱逐者线程"在后台运行着。
 * <p>
 * 上一层入口：{@link GenericObjectPool#setConfig(GenericObjectPoolConfig)}<br>
 * 顶层入口：{@link GenericObjectPool#GenericObjectPool(PooledObjectFactory, GenericObjectPoolConfig)}，
 * 在最后还会调用{@link #startEvictor(long)}来再次启动"空闲对象的驱逐者线程"。<br>
 * 这样在初始化时，这里创建的"驱逐者线程"就多余了，会立刻被销毁掉。<br>
 * 但这里为什么要这样实现呢？<br>
 * 我的理解是：为了能动态地更新"驱逐者线程"的调度间隔时间。
 *
 * @param timeBetweenEvictionRunsMillis
 *            number of milliseconds to sleep between evictor runs ("驱逐者线程"运行的间隔毫秒数)
 *
 * @see #getTimeBetweenEvictionRunsMillis
 */
public final void setTimeBetweenEvictionRunsMillis(
        long timeBetweenEvictionRunsMillis) {
    this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
    // 启动"驱逐者线程"
    this.startEvictor(timeBetweenEvictionRunsMillis);
}

 

二、startEvictor(long delay) - 启动“空闲对象的驱逐者线程”

如果有一个"驱逐者线程"(Evictor)运行着，则会先停止它；

然后创建一个新的"驱逐者线程"，并使用"驱逐者定时器"(EvictionTimer)进行调度。

// 空闲对象的驱逐回收策略
/** 用于初始化"驱逐者线程"的同步对象 */
final Object evictionLock = new Object();
/** 空闲对象驱逐者线程 */
private Evictor evictor = null; // @GuardedBy("evictionLock")
/** 驱逐检测对象迭代器 */
Iterator<PooledObject<T>> evictionIterator = null; // @GuardedBy("evictionLock")

/**
 * 启动"空闲对象的驱逐者线程"。
 * <p>
 * 如果有一个"驱逐者线程"({@link Evictor})运行着，则会先停止它；
 * 然后创建一个新的"驱逐者线程"，并使用"驱逐者定时器"({@link EvictionTimer})进行调度。
 *
 * <p>This method needs to be final, since it is called from a constructor. (因为它被一个构造器调用)
 * See POOL-195.</p>
 *
 * @param delay time in milliseconds before start and between eviction runs (驱逐者线程运行的开始和间隔时间 毫秒数)
 */
final void startEvictor(long delay) {
    synchronized (evictionLock) { // 同步锁
        if (null != evictor) {
            // 先释放申请的资源
            EvictionTimer.cancel(evictor);
            evictor = null;
            evictionIterator = null;
        }
        if (delay > 0) {
            evictor = new Evictor();
            EvictionTimer.schedule(evictor, delay, delay);
        }
    }
}

 

2.1 Evictor - "驱逐者线程"实现

Evictor，"空闲对象的驱逐者"定时任务，继承自 TimerTask。TimerTask 是一个可由定时器（Timer）调度执行一次或重复执行的任务。

核心实现逻辑：

1. evict()：执行numTests个空闲池对象的驱逐测试，驱逐那些符合驱逐条件的被检测对象；
2. ensureMinIdle()：试图确保配置的对象池中可用"空闲池对象"实例的最小数量。

/**
 * Class loader for evictor thread to use since in a J2EE or similar
 * environment the context class loader for the evictor thread may have
 * visibility of the correct factory. See POOL-161.
 * 驱逐者线程的类加载器
 */
private final ClassLoader factoryClassLoader;

// Inner classes

/**
 * "空闲对象的驱逐者"定时任务，继承自{@link TimerTask}。
 *
 * @see GenericObjectPool#GenericObjectPool(PooledObjectFactory, GenericObjectPoolConfig)
 * @see GenericKeyedObjectPool#setTimeBetweenEvictionRunsMillis(long)
 */
class Evictor extends TimerTask {

    /**
     * 运行对象池维护线程。
     * 驱逐对象具有驱逐者的资格，同时保证空闲实例可用的最小数量。
     * 因为调用"驱逐者线程"的定时器是被所有对象池共享的，
     * 但对象池可能存在不同的类加载器中，所以驱逐者必须确保采取的任何行为
     * 都得在与对象池相关的工厂的类加载器下。
     */
    @Override
    public void run() {
        ClassLoader savedClassLoader =
                Thread.currentThread().getContextClassLoader();
        try {
            // Set the class loader for the factory (设置"工厂的类加载器")
            Thread.currentThread().setContextClassLoader(
                    factoryClassLoader);

            // Evict from the pool (从"对象池"中驱逐)
            try {
                // 1. 执行numTests个空闲池对象的驱逐测试，驱逐那些符合驱逐条件的被检测对象
                evict(); // 抽象方法
            } catch(Exception e) {
                swallowException(e);
            } catch(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 {
                // 2. 试图确保配置的对象池中可用"空闲池对象"实例的最小数量
                ensureMinIdle(); // 抽象方法
            } catch (Exception e) {
                swallowException(e);
            }
        } finally {
            // Restore the previous CCL
            Thread.currentThread().setContextClassLoader(savedClassLoader);
        }
    }
}

 

2.2 EvictionTimer - "驱逐者定时器"实现

EvictionTimer，提供一个所有"对象池"共享的"空闲对象的驱逐定时器"。此类包装标准的定时器(Timer)，并追踪有多少个"对象池"使用它。

核心实现逻辑：

schedule(TimerTask task, long delay, long period)：添加指定的驱逐任务到这个定时器

/**
 * 提供一个所有"对象池"共享的"空闲对象的驱逐定时器"。
 *
 * 此类包装标准的定时器({@link Timer})，并追踪有多少个对象池使用它。
 *
 * 如果没有对象池使用这个定时器，它会被取消。这样可以防止线程一直运行着
 * (这会导致内存泄漏)，防止应用程序关闭或重新加载。
 * <p>
 * 此类是包范围的，以防止其被纳入到池框架的公共API中。
 * <p>
 * <font color="red">此类是线程安全的！</font>
 *
 * @since 2.0
 */
class EvictionTimer {

    /** Timer instance (定时器实例) */
    private static Timer _timer; //@GuardedBy("this")

    /** Static usage count tracker (使用计数追踪器) */
    private static int _usageCount; //@GuardedBy("this")

    /** Prevent instantiation (防止实例化) */
    private EvictionTimer() {
        // Hide the default constructor
    }

    /**
     * 添加指定的驱逐任务到这个定时器。
     * 任务，通过调用该方法添加的，必须调用{@link #cancel(TimerTask)}来取消这个任务，
     * 以防止内存或消除泄漏。
     *
     * @param task      Task to be scheduled (定时调度的任务)
     * @param delay     Delay in milliseconds before task is executed (任务执行前的等待时间)
     * @param period    Time in milliseconds between executions (执行间隔时间)
     */
    static synchronized void schedule(TimerTask task, long delay, long period) {
        if (null == _timer) {
            // Force the new Timer thread to be created with a context class
            // loader set to the class loader that loaded this library
            ClassLoader ccl = AccessController.doPrivileged(
                    new PrivilegedGetTccl());
            try {
                AccessController.doPrivileged(new PrivilegedSetTccl(
                        EvictionTimer.class.getClassLoader()));
                _timer = new Timer("commons-pool-EvictionTimer", true);
            } finally {
                AccessController.doPrivileged(new PrivilegedSetTccl(ccl));
            }
        }
        // 增加"使用计数器"，并调度"任务"
        _usageCount++;
        _timer.schedule(task, delay, period);
    }

    /**
     * 从定时器中删除指定的驱逐者任务。
     * <p>
     * Remove the specified eviction task from the timer.
     *
     * @param task      Task to be scheduled (定时调度任务)
     */
    static synchronized void cancel(TimerTask task) {
        task.cancel(); // 1. 将任务的状态标记为"取消(CANCELLED)"状态
        _usageCount--;
        if (_usageCount == 0) { // 2. 如果没有对象池使用这个定时器，定时器就会被取消
            _timer.cancel();
            _timer = null;
        }
    }

    /**
     * {@link PrivilegedAction} used to get the ContextClassLoader (获取"上下文类加载器")
     */
    private static class PrivilegedGetTccl implements PrivilegedAction<ClassLoader> {

        @Override
        public ClassLoader run() {
            return Thread.currentThread().getContextClassLoader();
        }
    }

    /**
     * {@link PrivilegedAction} used to set the ContextClassLoader (设置"上下文类加载器")
     */
    private static class PrivilegedSetTccl implements PrivilegedAction<Void> {

        /** ClassLoader */
        private final ClassLoader cl;

        /**
         * Create a new PrivilegedSetTccl using the given classloader
         * @param cl ClassLoader to use
         */
        PrivilegedSetTccl(ClassLoader cl) {
            this.cl = cl;
        }

        @Override
        public Void run() {
            Thread.currentThread().setContextClassLoader(cl);
            return null;
        }
    }

}

 

三、"驱逐者线程"和"驱逐者定时器"都准备就绪，现在真正地开始"空闲池对象"的驱逐检测操作（evict()）

BaseGenericObjectPool.evict()：驱逐检测操作的抽象声明

/**
 * 执行{@link numTests}个空闲池对象的驱逐测试，驱逐那些符合驱逐条件的被检测对象。
 * <p>
 * 如果{@code testWhileIdle}为{@code true}，则被检测的对象在访问期间是有效的(无效则会被删除)；
 * 否则，仅有那些池对象的空闲时间超过{@code minEvicableIdleTimeMillis}会被删除。
 *
 * @throws Exception when there is a problem evicting idle objects. (当这是一个有问题的驱逐空闲池对象时，才会抛出Exception异常。)
 */
public abstract void evict() throws Exception;

GenericObjectPool.evict()："通用对象池"的驱逐检测操作实现

核心实现逻辑：

1. 确保"对象池"还打开着

2. 获取"驱逐回收策略"

3. 获取"驱逐配置"

4. 对所有待检测的"空闲对象"进行驱逐检测

4.1 初始化"驱逐检测对象(空闲池对象)的迭代器"

4.2 将"池对象"标记为"开始驱逐状态"

4.3 进行真正的"驱逐检测"操作（EvictionPolicy.evict(...)）

4.3.1 如果"池对象"是可驱逐的，则销毁它

4.3.2 否则，是否允许空闲时进行有效性测试

4.3.2.1 先激活"池对象"

4.3.2.2 使用PooledObjectFactory.validateObject(PooledObject)进行"池对象"的有效性校验

4.3.2.2.1 如果"池对象"不是有效的，则销毁它

4.3.2.2.2 否则，还原"池对象"状态

4.3.2.3 通知"空闲对象队列"，驱逐测试已经结束

5. 是否要移除"被废弃的池对象"

/** 池的空闲池对象列表 */
private final LinkedBlockingDeque<PooledObject<T>> idleObjects =
    new LinkedBlockingDeque<PooledObject<T>>();
/** 池对象工厂 */
private final PooledObjectFactory<T> factory;

// 空闲对象的驱逐回收策略
/** 用于初始化"驱逐者线程"的同步对象 */
final Object evictionLock = new Object();
/** 空闲对象驱逐者线程 */
private Evictor evictor = null; // @GuardedBy("evictionLock")
/** 驱逐检测对象("空闲池对象")的迭代器 */
Iterator<PooledObject<T>> evictionIterator = null; // @GuardedBy("evictionLock")

/** 被废弃的池对象追踪的配置属性 */
private volatile AbandonedConfig abandonedConfig = null;

/**
 * {@inheritDoc}
 * <p>
 * 按顺序对被审查的对象进行连续驱逐检测，对象是以"从最老到最年轻"的顺序循环。
 */
@Override
public void evict() throws Exception {
    // 1. 确保"对象池"还打开着
    this.assertOpen();

    if (idleObjects.size() > 0) {
        PooledObject<T> underTest = null; // 测试中的池对象
        // 2. 获取"驱逐回收策略"
        EvictionPolicy<T> evictionPolicy = this.getEvictionPolicy();

        synchronized (evictionLock) { // 驱逐锁定
            // 3. 获取"驱逐配置"
            EvictionConfig evictionConfig = new EvictionConfig(
                    this.getMinEvictableIdleTimeMillis(),
                    this.getSoftMinEvictableIdleTimeMillis(),
                    this.getMinIdle()
                    );

            // 4. 对所有待检测的"空闲对象"进行驱逐检测
            for (int i = 0, m = this.getNumTests(); i < m; i++) {
                // 4.1 初始化"驱逐检测对象(空闲池对象)的迭代器"
                if (evictionIterator == null || !evictionIterator.hasNext()) { // 已对所有空闲对象完成一次遍历
                    // 根据"对象池使用行为"赋值驱逐迭代器
                    if (this.getLifo()) {
                        evictionIterator = idleObjects.descendingIterator();
                    } else {
                        evictionIterator = idleObjects.iterator();
                    }
                }
                if (!evictionIterator.hasNext()) {
                    // Pool exhausted, nothing to do here (对象池被耗尽，无可用池对象)
                    return;
                }

                try {
                    underTest = evictionIterator.next();
                } catch (NoSuchElementException nsee) {
                    // Object was borrowed in another thread (池对象被其它请求线程借用了)
                    // Don't count this as an eviction test so reduce i;
                    i--;
                    evictionIterator = null;
                    continue;
                }

                // 4.2 将"池对象"标记为"开始驱逐状态"
                if (!underTest.startEvictionTest()) {
                    // Object was borrowed in another thread
                    // Don't count this as an eviction test so reduce i;
                    i--;
                    continue;
                }

                boolean testWhileIdle = this.getTestWhileIdle(); // 是否要在对象空闲时测试有效性

                // 4.3 进行真正的"驱逐检测"操作（EvictionPolicy.evict(...)）
                if (evictionPolicy.evict(evictionConfig, underTest,
                        idleObjects.size())) {
                    // 4.3.1 如果"池对象"是可驱逐的，则销毁它
                    this.destroy(underTest);
                    destroyedByEvictorCount.incrementAndGet();
                } else {
                    // 4.3.2 否则，是否允许空闲时进行有效性测试
                    if (testWhileIdle) { // 允许空闲时进行有效性测试
                        // 4.3.2.1 先激活"池对象"
                        boolean active = false;
                        try {
                            factory.activateObject(underTest);
                            active = true;
                        } catch (Exception e) {
                            this.destroy(underTest);
                            destroyedByEvictorCount.incrementAndGet();
                        }
                        // 4.3.2.2 使用PooledObjectFactory.validateObject(PooledObject)进行"池对象"的有效性校验
                        if (active) {
                            if (!factory.validateObject(underTest)) {
                                // 4.3.2.2.1 如果"池对象"不是有效的，则销毁它
                                this.destroy(underTest);
                                destroyedByEvictorCount.incrementAndGet();
                            } else {
                                try {
                                    // 4.3.2.2.2 否则，还原"池对象"状态
                                    factory.passivateObject(underTest);
                                } catch (Exception e) {
                                    this.destroy(underTest);
                                    destroyedByEvictorCount.incrementAndGet();
                                }
                            }
                        }
                    }
                    // 4.3.2.3 通知"空闲对象队列"，驱逐测试已经结束
                    if (!underTest.endEvictionTest(idleObjects)) {
                        // TODO - May need to add code here once additional
                        // states are used
                    }
                }
            }
        }
    }
    // 5. 是否要移除"被废弃的池对象"
    AbandonedConfig ac = this.abandonedConfig;
    if (ac != null && ac.getRemoveAbandonedOnMaintenance()) {
        this.removeAbandoned(ac);
    }
}

BaseGenericObjectPool.ensureMinIdle()："确保对象池中可用"空闲池对象"实例的最小数量"的抽象声明

 

/**
 * 试图确保配置的对象池中可用"空闲池对象"实例的最小数量。
 *
 * @throws Exception if an error occurs creating idle instances
 */
abstract void ensureMinIdle() throws Exception;

 

 

GenericObjectPool.ensureMinIdle()："确保对象池中可用"空闲池对象"实例的最小数量"实现

@Override
void ensureMinIdle() throws Exception {
    this.ensureIdle(this.getMinIdle(), true);
}

/**
 * 返回对象池中维护的空闲对象的最小数量目标。
 * <p>
 * 此设置仅会在{@link #getTimeBetweenEvictionRunsMillis()}的返回值大于0时，
 * 且该值是正整数时才会生效。
 * <p>
 * 默认是 {@code 0}，即对象池不维护空闲的池对象。
 *
 * @return The minimum number of objects. (空闲对象的最小数量)
 *
 * @see #setMinIdle(int)
 * @see #setMaxIdle(int)
 * @see #setTimeBetweenEvictionRunsMillis(long)
 */
@Override
public int getMinIdle() {
    int maxIdleSave = this.getMaxIdle();
    if (this.minIdle > maxIdleSave) {
        return maxIdleSave;
    } else {
        return minIdle;
    }
}

/**
 * 试图确保对象池中存在的{@code idleCount}个空闲实例。
 * <p>
 * 创建并添加空闲实例，直到空闲实例数量({@link #getNumIdle()})达到{@code idleCount}个，
 * 或者池对象的总数(空闲、检出、被创建)达到{@link #getMaxTotal()}。
 * 如果{@code always}是false，则不会创建实例，除非线程在等待对象池中的实例检出。
 *
 * @param idleCount the number of idle instances desired (期望的空闲实例数量)
 * @param always true means create instances even if the pool has no threads waiting
 *          (true意味着即使对象池没有线程等待，也会创建实例)
 * @throws Exception if the factory's makeObject throws
 */
private void ensureIdle(int idleCount, boolean always) throws Exception {
    if (idleCount < 1 || this.isClosed() || (!always && !idleObjects.hasTakeWaiters())) {
        return;
    }

    while (idleObjects.size() < idleCount) {
        PooledObject<T> p = this.create();
        if (p == null) {
            // Can't create objects (不能创建对象), no reason to think another call to
            // create will work. Give up.
            break;
        }
        // "新的池对象"可以立刻被使用
        if (this.getLifo()) { // LIFO(后进先出)
            idleObjects.addFirst(p);
        } else { // FIFO(先进先出)
            idleObjects.addLast(p);
        }
    }
}

/**
 * 尝试着创建一个新的包装的池对象。
 *
 * @return The new wrapped pooled object
 *
 * @throws Exception if the object factory's {@code makeObject} fails
 */
private PooledObject<T> create() throws Exception {
    // 1. 对象池是否被耗尽判断
    int localMaxTotal = getMaxTotal();
    long newCreateCount = createCount.incrementAndGet();
    if (localMaxTotal > -1 && newCreateCount > localMaxTotal ||
            newCreateCount > Integer.MAX_VALUE) {
        createCount.decrementAndGet();
        return null; // 没有池对象可创建
    }

    final PooledObject<T> p;
    try {
        // 2. 使用PooledObjectFactory.makeObject()来制造一个新的池对象
        p = factory.makeObject();
    } catch (Exception e) {
        createCount.decrementAndGet();
        throw e;
    }

    AbandonedConfig ac = this.abandonedConfig;
    if (ac != null && ac.getLogAbandoned()) {
        p.setLogAbandoned(true);
    }

    createdCount.incrementAndGet();
    // 3. 将新创建的池对象追加到"池的所有对象映射表"中
    allObjects.put(p.getObject(), p);
    return p;
}

 

3.1 "驱逐回收策略"实现

EvictionConfig："驱逐回收策略"配置信息

/**
 * 此类用于将对象池的配置信息传递给"驱逐回收策略({@link EvictionPolicy})"实例。
 * <p>
 * <font color="red">此类是不可变的，且是线程安全的。</font>
 *
 * @since 2.0
 */
public class EvictionConfig {

    // final 字段修饰保证其不可变性
    /** 池对象的最大空闲驱逐时间（当池对象的空闲时间超过该值时，立马被强制驱逐掉） */
    private final long idleEvictTime;
    /** 池对象的最小空闲驱逐时间（当池对象的空闲时间超过该值时，被纳入驱逐对象列表里） */
    private final long idleSoftEvictTime;
    /** 对象池的最小空闲池对象数量 */
    private final int minIdle;


    /**
     * 创建一个新的"驱逐回收策略"配置实例。
     * <p>
     * <font color="red">实例是不可变的。</font>
     *
     * @param poolIdleEvictTime Expected to be provided by (池对象的最大空闲驱逐时间(ms))
     *        {@link BaseGenericObjectPool#getMinEvictableIdleTimeMillis()}
     * @param poolIdleSoftEvictTime Expected to be provided by (池对象的最小空闲驱逐时间(ms))
     *        {@link BaseGenericObjectPool#getSoftMinEvictableIdleTimeMillis()}
     * @param minIdle Expected to be provided by (对象池的最小空闲池对象数量)
     *        {@link GenericObjectPool#getMinIdle()} or
     *        {@link GenericKeyedObjectPool#getMinIdlePerKey()}
     */
    public EvictionConfig(long poolIdleEvictTime, long poolIdleSoftEvictTime,
            int minIdle) {
        if (poolIdleEvictTime > 0) {
            idleEvictTime = poolIdleEvictTime;
        } else {
            idleEvictTime = Long.MAX_VALUE;
        }
        if (poolIdleSoftEvictTime > 0) {
            idleSoftEvictTime = poolIdleSoftEvictTime;
        } else {
            idleSoftEvictTime  = Long.MAX_VALUE;
        }
        this.minIdle = minIdle;
    }

    /**
     * 获取"池对象的最大空闲驱逐时间(ms)"。
     * <p>
     * 当池对象的空闲时间超过该值时，立马被强制驱逐掉。
     * <p>
     * How the evictor behaves based on this value will be determined by the
     * configured {@link EvictionPolicy}.
     *
     * @return The {@code idleEvictTime} in milliseconds
     */
    public long getIdleEvictTime() {
        return idleEvictTime;
    }

    /**
     * 获取"池对象的最小空闲驱逐时间(ms)"。
     * <p>
     * 当池对象的空闲时间超过该值时，被纳入驱逐对象列表里。
     * <p>
     * How the evictor behaves based on this value will be determined by the
     * configured {@link EvictionPolicy}.
     *
     * @return The (@code idleSoftEvictTime} in milliseconds
     */
    public long getIdleSoftEvictTime() {
        return idleSoftEvictTime;
    }

    /**
     * 获取"对象池的最小空闲池对象数量"。
     * <p>
     * How the evictor behaves based on this value will be determined by the
     * configured {@link EvictionPolicy}.
     *
     * @return The {@code minIdle}
     */
    public int getMinIdle() {
        return minIdle;
    }

}

 

EvictionPolicy<T>："驱逐回收策略"声明

/**
 * 为了提供对象池的一个自定义"驱逐回收策略"，
 * 使用者必须提供该接口的一个实现(如{@link DefaultEvictionPolicy})。
 *
 * @param <T> the type of objects in the pool (对象池中对象的类型)
 *
 * @since 2.0
 */
public interface EvictionPolicy<T> {

    /**
     * 一个对象池中的空闲对象是否应该被驱逐，调用此方法来测试。（驱逐行为声明）
     *
     * @param config    The pool configuration settings related to eviction (与驱逐相关的对象池配置设置)
     * @param underTest The pooled object being tested for eviction (正在被驱逐测试的池对象)
     * @param idleCount The current number of idle objects in the pool including
     *                      the object under test (当前对象池中的空闲对象数，包括测试中的对象)
     * @return <code>true</code> if the object should be evicted, otherwise
     *             <code>false</code> (如果池对象应该被驱逐掉，就返回{@code true}；否则，返回{@code false}。)
     */
    boolean evict(EvictionConfig config, PooledObject<T> underTest,
            int idleCount);

}

 

DefaultEvictionPolicy<T>：提供用在对象池的"驱逐回收策略"的默认实现，继承自EvictionPolicy<T>

/**
 * 提供用在对象池的"驱逐回收策略"的默认实现，继承自{@link EvictionPolicy}。
 * <p>
 * 如果满足以下条件，对象将被驱逐：
 * <ul>
 * <li>池对象的空闲时间超过{@link GenericObjectPool#getMinEvictableIdleTimeMillis()}
 * <li>对象池中的空闲对象数超过{@link GenericObjectPool#getMinIdle()}，且池对象的空闲时间超过{@link GenericObjectPool#getSoftMinEvictableIdleTimeMillis()}
 * </ul>
 * <font color="red">此类是不可变的，且是线程安全的。</font>
 *
 * @param <T> the type of objects in the pool (对象池中对象的类型)
 *
 * @since 2.0
 */
public class DefaultEvictionPolicy<T> implements EvictionPolicy<T> {

    /**
     * 如果对象池中的空闲对象是否应该被驱逐，调用此方法来测试。（驱逐行为实现）
     */
    @Override
    public boolean evict(EvictionConfig config, PooledObject<T> underTest,
            int idleCount) {

        if ((idleCount > config.getMinIdle() &&
                underTest.getIdleTimeMillis() > config.getIdleSoftEvictTime())
                || underTest.getIdleTimeMillis() > config.getIdleEvictTime()) {
            return true;
        }
        return false;
    }

}

 

其他相关实现

 

// --- internal attributes (内部属性) -------------------------------------------------

/** 对象池中的所有池对象映射表 */
private final ConcurrentMap<T, PooledObject<T>> allObjects =
    new ConcurrentHashMap<T, PooledObject<T>>();
/** 池的空闲池对象列表 */
private final LinkedBlockingDeque<PooledObject<T>> idleObjects =
    new LinkedBlockingDeque<PooledObject<T>>();

/** 池对象工厂 */
private final PooledObjectFactory<T> factory;


/**
 * 计算空闲对象驱逐者一轮测试的对象数量。
 *
 * @return The number of objects to test for validity (要测试其有效性的对象数量)
 */
private int getNumTests() {
    int numTestsPerEvictionRun = this.getNumTestsPerEvictionRun();
    if (numTestsPerEvictionRun >= 0) {
        return Math.min(numTestsPerEvictionRun, idleObjects.size());
    } else {
        return (int) (Math.ceil(idleObjects.size() /
                Math.abs((double) numTestsPerEvictionRun)));
    }
}

/**
 * 销毁一个包装的"池对象"。
 *
 * @param toDestory The wrapped pooled object to destroy
 *
 * @throws Exception If the factory fails to destroy the pooled object
 *                   cleanly
 */
private void destroy(PooledObject<T> toDestory) throws Exception {
    // 1. 设置这个"池对象"的状态为"无效(INVALID)"
    toDestory.invalidate();
    // 2. 将这个"池对象"从"空闲对象列表"和"所有对象列表"中移除掉
    idleObjects.remove(toDestory);
    allObjects.remove(toDestory.getObject());
    try {
        // 3. 使用PooledObjectFactory.destroyObject(PooledObject<T> p)来销毁这个不再需要的池对象
        factory.destroyObject(toDestory);
    } finally {
        destroyedCount.incrementAndGet();
        createCount.decrementAndGet();
    }
}

/**
 * 恢复被废弃的对象，它已被检测出超过{@code AbandonedConfig#getRemoveAbandonedTimeout()
 * removeAbandonedTimeout}未被使用。
 * <p>
 * <font color="red">注意：需要考虑性能损耗，因为它会对对象池中的所有池对象进行检测！</font>
 *
 * @param ac The configuration to use to identify abandoned objects
 */
private void removeAbandoned(AbandonedConfig ac) {
    // 1. Generate a list of abandoned objects to remove (生成一个要被删除的被废弃的对象列表)
    final long now = System.currentTimeMillis();
    final long timeout =
            now - (ac.getRemoveAbandonedTimeout() * 1000L);
    List<PooledObject<T>> remove = new ArrayList<PooledObject<T>>();
    Iterator<PooledObject<T>> it = allObjects.values().iterator();
    while (it.hasNext()) {
        PooledObject<T> pooledObject = it.next();
        synchronized (pooledObject) {
            // 从"所有池对象"中挑选出状态为"使用中"的池对象，且空闲时间已超过了"对象的移除超时时间"
            if (pooledObject.getState() == PooledObjectState.ALLOCATED &&
                    pooledObject.getLastUsedTime() <= timeout) {
                // 标记池对象为"被废弃"状态，并添加到删除列表中
                pooledObject.markAbandoned();
                remove.add(pooledObject);
            }
        }
    }

    // 2. Now remove the abandoned objects (移除所有被废弃的对象)
    Iterator<PooledObject<T>> itr = remove.iterator();
    while (itr.hasNext()) {
        PooledObject<T> pooledObject = itr.next();
        if (ac.getLogAbandoned()) {
            pooledObject.printStackTrace(ac.getLogWriter());
        }
        try {
            this.invalidateObject(pooledObject.getObject());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

 

综上所述，真正的"空闲对象的驱逐检测操作"在 GenericObjectPool.evict() 中实现，其被包装在"驱逐者定时器任务(Evictor)"中，并由"驱逐定时器(EvictionTimer)"定时调度，而启动"驱逐者线程"则由 BaseGenericObjectPool.startEvictor(long delay) 实现。

 

http://bert82503.iteye.com/blog/2171595