* idle object evictor thread (if any).     *     * @see #setNumTestsPerEvictionRun     * @see #setTimeBetweenEvictionRunsMillis     */    public synchronized int getNumTestsPerEvictionRun() {        return _numTestsPerEvictionRun;    }    /**     * Sets the max number of objects to examine during each run of the     * idle object evictor thread (if any).     * <p>     * When a negative value is supplied, <tt>ceil({@link #getNumIdle})/abs({@link #getNumTestsPerEvictionRun})</tt>     * tests will be run.  I.e., when the value is <i>-n</i>, roughly one <i>n</i>th of the     * idle objects will be tested per run.     *     * @see #getNumTestsPerEvictionRun     * @see #setTimeBetweenEvictionRunsMillis     */    public synchronized void setNumTestsPerEvictionRun(int numTestsPerEvictionRun) {        _numTestsPerEvictionRun = numTestsPerEvictionRun;    }    /**     * Returns the minimum amount of time an object may sit idle in the pool     * before it is eligable for eviction by the idle object evictor     * (if any).     *     * @see #setMinEvictableIdleTimeMillis     * @see #setTimeBetweenEvictionRunsMillis     */    public synchronized long getMinEvictableIdleTimeMillis() {        return _minEvictableIdleTimeMillis;    }    /**     * Sets the minimum amount of time an object may sit idle in the pool     * before it is eligable for eviction by the idle object evictor     * (if any).     * When non-positive, no objects will be evicted from the pool     * due to idle time alone.     *     * @see #getMinEvictableIdleTimeMillis     * @see #setTimeBetweenEvictionRunsMillis     */    public synchronized void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis) {        _minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;    }    /**     * Returns the minimum amount of time an object may sit idle in the pool     * before it is eligable for eviction by the idle object evictor     * (if any), with the extra condition that at least     * "minIdle" amount of object remain in the pool.     *     * @see #setSoftMinEvictableIdleTimeMillis     */    public synchronized long getSoftMinEvictableIdleTimeMillis() {        return _softMinEvictableIdleTimeMillis;    }    /**     * Sets the minimum amount of time an object may sit idle in the pool     * before it is eligable for eviction by the idle object evictor     * (if any), with the extra condition that at least     * "minIdle" amount of object remain in the pool.     * When non-positive, no objects will be evicted from the pool     * due to idle time alone.     *     * @see #getSoftMinEvictableIdleTimeMillis     */    public synchronized void setSoftMinEvictableIdleTimeMillis(long softMinEvictableIdleTimeMillis) {        _softMinEvictableIdleTimeMillis = softMinEvictableIdleTimeMillis;    }    /**     * When <tt>true</tt>, objects will be     * {@link PoolableObjectFactory#validateObject validated}     * by the idle object evictor (if any).  If an object     * fails to validate, it will be dropped from the pool.     *     * @see #setTestWhileIdle     * @see #setTimeBetweenEvictionRunsMillis     */    public synchronized boolean getTestWhileIdle() {        return _testWhileIdle;    }    /**     * When <tt>true</tt>, objects will be     * {@link PoolableObjectFactory#validateObject validated}     * by the idle object evictor (if any).  If an object     * fails to validate, it will be dropped from the pool.     *     * @see #getTestWhileIdle     * @see #setTimeBetweenEvictionRunsMillis     */    public synchronized void setTestWhileIdle(boolean testWhileIdle) {        _testWhileIdle = testWhileIdle;    }    /**     * Sets my configuration.     * @see GenericObjectPool.Config     */    public synchronized void setConfig(GenericObjectPool.Config conf) {        setMaxIdle(conf.maxIdle);        setMinIdle(conf.minIdle);        setMaxActive(conf.maxActive);        setMaxWait(conf.maxWait);        setWhenExhaustedAction(conf.whenExhaustedAction);        setTestOnBorrow(conf.testOnBorrow);        setTestOnReturn(conf.testOnReturn);        setTestWhileIdle(conf.testWhileIdle);        setNumTestsPerEvictionRun(conf.numTestsPerEvictionRun);        setMinEvictableIdleTimeMillis(conf.minEvictableIdleTimeMillis);        setTimeBetweenEvictionRunsMillis(conf.timeBetweenEvictionRunsMillis);        notifyAll();    }    //-- ObjectPool methods ------------------------------------------    public synchronized Object borrowObject() throws Exception {        assertOpen();        long starttime = System.currentTimeMillis();        for(;;) {            ObjectTimestampPair pair = null;            // if there are any sleeping, just grab one of those            try {                pair = (ObjectTimestampPair)(_pool.removeFirst());            } catch(NoSuchElementException e) {                ; /* ignored */            }            // otherwise            if(null == pair) {                // check if we can create one                // (note we know that the num sleeping is 0, else we wouldn't be here)                if(_maxActive < 0 || _numActive < _maxActive) {                    // allow new object to be created                } else {                    // the pool is exhausted                    switch(_whenExhaustedAction) {                        case WHEN_EXHAUSTED_GROW:                            // allow new object to be created                            break;                        case WHEN_EXHAUSTED_FAIL:                            throw new NoSuchElementException("Pool exhausted");                        case WHEN_EXHAUSTED_BLOCK:                            try {                                if(_maxWait <= 0) {                                    wait();                                } else {                                    // this code may be executed again after a notify then continue cycle                                    // so, need to calculate the amount of time to wait                                    final long elapsed = (System.currentTimeMillis() - starttime);                                    final long waitTime = _maxWait - elapsed;                                    if (waitTime > 0)                                    {                                        wait(waitTime);                                    }                                }                            } catch(InterruptedException e) {                                // ignored                            }                            if(_maxWait > 0 && ((System.currentTimeMillis() - starttime) >= _maxWait)) {                                throw new NoSuchElementException("Timeout waiting for idle object");                            } else {                                continue; // keep looping                            }                        default:                            throw new IllegalArgumentException("WhenExhaustedAction property " + _whenExhaustedAction + " not recognized.");                    }                }            }            _numActive++;            // create new object when needed            boolean newlyCreated = false;            if(null == pair) {                try {                    Object obj = _factory.makeObject();                    pair = new ObjectTimestampPair(obj);                    newlyCreated = true;                } finally {                    if (!newlyCreated) {                        // object cannot be created                        _numActive--;                        notifyAll();                    }                }            }            // activate & validate the object            try {                _factory.activateObject(pair.value);                if(_testOnBorrow && !_factory.validateObject(pair.value)) {                    throw new Exception("ValidateObject failed");                }                return pair.value;            }            catch (Throwable e) {                // object cannot be activated or is invalid                _numActive--;                notifyAll();                try {                    _factory.destroyObject(pair.value);                }                catch (Throwable e2) {                    // cannot destroy broken object                }                if(newlyCreated) {                    throw new NoSuchElementException("Could not create a validated object, cause: " + e.getMessage());                }                else {                    continue; // keep looping                }            }        }    }    public synchronized void invalidateObject(Object obj) throws Exception {        assertOpen();        try {            _factory.destroyObject(obj);        }        finally {            _numActive--;            notifyAll(); // _numActive has changed        }    }    public synchronized void clear() {        assertOpen();        for(Iterator it = _pool.iterator(); it.hasNext(); ) {            try {                _factory.destroyObject(((ObjectTimestampPair)(it.next())).value);            } catch(Exception e) {                // ignore error, keep destroying the rest            }            it.remove();        }        _pool.clear();        notifyAll(); // num sleeping has changed    }    public synchronized int getNumActive() {        assertOpen();        return _numActive;    }    public synchronized int getNumIdle() {        assertOpen();        return _pool.size();    }    public synchronized void returnObject(Object obj) throws Exception {        assertOpen();        addObjectToPool(obj, true);    }    private void addObjectToPool(Object obj, boolean decrementNumActive) throws Exception {        boolean success = true;        if(_testOnReturn && !(_factory.validateObject(obj))) {            success = false;        } else {            try {                _factory.passivateObject(obj);            } catch(Exception e) {                success = false;            }        }        boolean shouldDestroy = !success;        if (decrementNumActive) {            _numActive--;        }        if((_maxIdle >= 0) && (_pool.size() >= _maxIdle)) {            shouldDestroy = true;        } else if(success) {            _pool.addLast(new ObjectTimestampPair(obj));        }        notifyAll(); // _numActive has changed        if(shouldDestroy) {            try {                _factory.destroyObject(obj);            } catch(Exception e) {                // ignored            }        }    }    public synchronized void close() throws Exception {        clear();        _pool = null;        _factory = null;        startEvictor(-1L);        super.close();    }    public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException {        assertOpen();        if(0 < getNumActive()) {            throw new IllegalStateException("Objects are already active");        } else {            clear();            _factory = factory;        }    }    public synchronized void evict() throws Exception {        assertOpen();        if(!_pool.isEmpty()) {            ListIterator iter;            if (evictLastIndex < 0) {                iter = _pool.listIterator(_pool.size());            } else {                iter = _pool.listIterator(evictLastIndex);            }            for(int i=0,m=getNumTests();i<m;i++) {                if(!iter.hasPrevious()) {                    iter = _pool.listIterator(_pool.size());                }                boolean removeObject = false;