Apache Commons Pool2-空闲对象的驱逐检测机制

转载于http://www.myexception.cn/apache/1814568.html


以下面3个步骤来循序渐进地深入剖析其实现原理:
启动“驱逐者线程”(startEvictor(...))的2个入口
在启动时,实例化"驱逐者线程"(Evictor),并调度"驱逐者定时器"(EvictionTimer)
进入真正地"空闲池对象"的驱逐检测操作(evict())
一、启动“驱逐者线程”(startEvictor(...))共有2个入口
1. 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 中设置"驱逐者线程定时器"的运行间隔时间的方法
    /**
     * 设置"空闲对象的驱逐者线程"运行间隔休眠的毫秒数。(同时,会立即启动"空闲对象的驱逐者线程")
     * <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>
     * 当该方法被调用时,如果有一个"驱逐者线程"运行着,则会停止它并使用一个新的"驱逐者线程"替换它。
     *
     * <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)调度执行一次或重复执行的任务。
    /**
     * 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 {
                    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 {
                    ensureMinIdle(); // 抽象方法
                } catch (Exception e) {
                    swallowException(e);
                }
            } finally {
                // Restore the previous CCL
                Thread.currentThread().setContextClassLoader(savedClassLoader);
            }
        }
    }
 
2.2 "驱逐者定时器"(EvictionTimer)实现
EvictionTimer,提供一个所有对象池共享的"空闲对象的驱逐定时器"。此类包装标准的定时器(Timer),并追踪有多少个对象池使用它。
/**
 * 提供一个所有对象池共享的"空闲对象的驱逐定时器"。
 * 
 * 此类包装标准的定时器({@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(),通用对象池的驱逐检测操作实现。
 
    /** 池的空闲池对象列表 */
    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();


        // 2. 对"所有空闲对象"进行驱逐检测
        if (idleObjects.size() > 0) {


            PooledObject<T> underTest = null; // 测试中的池对象
            EvictionPolicy<T> evictionPolicy = this.getEvictionPolicy(); // 驱逐回收策略


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


                for (int i = 0, m = this.getNumTests(); i < m; i++) {
                    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;
                    }


                    // 3. 将池对象标记为开始"驱逐"状态
                    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. 进行真正的驱逐校验操作
                    if (evictionPolicy.evict(evictionConfig, underTest,
                            idleObjects.size())) {
                    // 如果池对象是可驱逐的,则销毁它
                    this.destroy(underTest);
                        destroyedByEvictorCount.incrementAndGet();
                    } else {
                        if (testWhileIdle) { // 允许空闲时进行有效性测试
                        // 5.1 先激活池对象
                            boolean active = false;
                            try {
                                factory.activateObject(underTest);
                                active = true;
                            } catch (Exception e) {
                            this.destroy(underTest);
                                destroyedByEvictorCount.incrementAndGet();
                            }
                            // 5.2 使用PooledObjectFactory.validateObject(PooledObject)进行池对象的有效性校验
                            if (active) {
                                if (!factory.validateObject(underTest)) {
                                // 如果池对象不是有效的,则销毁它
                                this.destroy(underTest);
                                    destroyedByEvictorCount.incrementAndGet();
                                } else {
                                    try {
                                    // 如果池对象有效,则还原状态
                                        factory.passivateObject(underTest);
                                    } catch (Exception e) {
                                    this.destroy(underTest);
                                        destroyedByEvictorCount.incrementAndGet();
                                    }
                                }
                            }
                        }
                        // 6. 通知空闲对象队列,驱逐测试已经结束
                        if (!underTest.endEvictionTest(idleObjects)) {
                            // TODO - May need to add code here once additional
                            // states are used
                        }
                    }
                }
            }
        }
        // 7. 是否要"移除被废弃的池对象"
        AbandonedConfig ac = this.abandonedConfig;
        if (ac != null && ac.getRemoveAbandonedOnMaintenance()) {
        this.removeAbandoned(ac);
        }
    }
 
 
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) 实现。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值