org.apache.commons.pool.impl

Class GenericObjectPool

Implemented Interfaces:
ObjectPool

public class GenericObjectPool
extends BaseObjectPool
implements ObjectPool

A configurable ObjectPool implementation.

When coupled with the appropriate PoolableObjectFactory, GenericObjectPool provides robust pooling functionality for arbitrary objects.

A GenericObjectPool provides a number of configurable parameters:

  • When testOnBorrow is set, the pool will attempt to validate each object before it is returned from the borrowObject() method. (Using the provided factory's PoolableObjectFactory.validateObject(Object) method.) Objects that fail to validate will be dropped from the pool, and a different object will be borrowed.
  • When testOnReturn is set, the pool will attempt to validate each object before it is returned to the pool in the returnObject(Object) method. (Using the provided factory's PoolableObjectFactory.validateObject(Object) method.) Objects that fail to validate will be dropped from the pool.
  • Optionally, one may configure the pool to examine and possibly evict objects as they sit idle in the pool. This is performed by an "idle object eviction" thread, which runs asychronously. The idle object eviction thread may be configured using the following attributes:

    GenericObjectPool is not usable without a PoolableObjectFactory. A non-null factory must be provided either as a constructor argument or via a call to setFactory(PoolableObjectFactory) before the pool is used.

    Version:
    $Revision: 390563 $ $Date: 2006-03-31 20:28:14 -0500 (Fri, 31 Mar 2006) $
    Authors:
    Rodney Waldhoff
    Dirk Verbeeck
    See Also:
    GenericKeyedObjectPool

    Nested Class Summary

    static class
    GenericObjectPool.Config
    A simple "struct" encapsulating the configuration information for a GenericObjectPool.

    Field Summary

    static int
    DEFAULT_MAX_ACTIVE
    The default cap on the total number of active instances from the pool.
    static int
    DEFAULT_MAX_IDLE
    The default cap on the number of "sleeping" instances in the pool.
    static long
    DEFAULT_MAX_WAIT
    The default maximum amount of time (in millis) the borrowObject() method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK.
    static long
    DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS
    The default value for getMinEvictableIdleTimeMillis().
    static int
    DEFAULT_MIN_IDLE
    The default minimum number of "sleeping" instances in the pool before before the evictor thread (if active) spawns new objects.
    static int
    DEFAULT_NUM_TESTS_PER_EVICTION_RUN
    The default number of objects to examine per run in the idle object evictor.
    static long
    DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS
    The default value for getSoftMinEvictableIdleTimeMillis().
    static boolean
    DEFAULT_TEST_ON_BORROW
    The default "test on borrow" value.
    static boolean
    DEFAULT_TEST_ON_RETURN
    The default "test on return" value.
    static boolean
    DEFAULT_TEST_WHILE_IDLE
    The default "test while idle" value.
    static long
    DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS
    The default "time between eviction runs" value.
    static byte
    DEFAULT_WHEN_EXHAUSTED_ACTION
    The default "when exhausted action" for the pool.
    static byte
    WHEN_EXHAUSTED_BLOCK
    A "when exhausted action" type indicating that when the pool is exhausted (i.e., the maximum number of active objects has been reached), the borrowObject() method should block until a new object is available, or the maximum wait time has been reached.
    static byte
    WHEN_EXHAUSTED_FAIL
    A "when exhausted action" type indicating that when the pool is exhausted (i.e., the maximum number of active objects has been reached), the borrowObject() method should fail, throwing a NoSuchElementException.
    static byte
    WHEN_EXHAUSTED_GROW
    A "when exhausted action" type indicating that when the pool is exhausted (i.e., the maximum number of active objects has been reached), the borrowObject() method should simply create a new object anyway.

    Constructor Summary

    GenericObjectPool()
    Create a new GenericObjectPool.
    GenericObjectPool(PoolableObjectFactory factory)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, long softMinEvictableIdleTimeMillis)
    Create a new GenericObjectPool using the specified values.
    GenericObjectPool(PoolableObjectFactory factory, GenericObjectPool.Config config)
    Create a new GenericObjectPool using the specified values.

    Method Summary

    void
    addObject()
    Create an object, and place it into the pool.
    Object
    borrowObject()
    void
    clear()
    void
    close()
    void
    evict()
    int
    getMaxActive()
    Returns the cap on the total number of active instances from my pool.
    int
    getMaxIdle()
    Returns the cap on the number of "idle" instances in the pool.
    long
    getMaxWait()
    Returns the maximum amount of time (in milliseconds) the borrowObject() method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK.
    long
    getMinEvictableIdleTimeMillis()
    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).
    int
    getMinIdle()
    Returns the minimum number of objects allowed in the pool before the evictor thread (if active) spawns new objects.
    int
    getNumActive()
    int
    getNumIdle()
    int
    getNumTestsPerEvictionRun()
    Returns the max number of objects to examine during each run of the idle object evictor thread (if any).
    long
    getSoftMinEvictableIdleTimeMillis()
    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.
    boolean
    getTestOnBorrow()
    When true, objects will be validated before being returned by the borrowObject() method.
    boolean
    getTestOnReturn()
    When true, objects will be validated before being returned to the pool within the returnObject(Object).
    boolean
    getTestWhileIdle()
    When true, objects will be validated by the idle object evictor (if any).
    long
    getTimeBetweenEvictionRunsMillis()
    Returns the number of milliseconds to sleep between runs of the idle object evictor thread.
    byte
    getWhenExhaustedAction()
    Returns the action to take when the borrowObject() method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).
    void
    invalidateObject(Object obj)
    void
    returnObject(Object obj)
    void
    setConfig(GenericObjectPool.Config conf)
    Sets my configuration.
    void
    setFactory(PoolableObjectFactory factory)
    void
    setMaxActive(int maxActive)
    Sets the cap on the total number of active instances from my pool.
    void
    setMaxIdle(int maxIdle)
    Sets the cap on the number of "idle" instances in the pool.
    void
    setMaxWait(long maxWait)
    Sets the maximum amount of time (in milliseconds) the borrowObject() method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK.
    void
    setMinEvictableIdleTimeMillis(long 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).
    void
    setMinIdle(int minIdle)
    Sets the minimum number of objects allowed in the pool before the evictor thread (if active) spawns new objects.
    void
    setNumTestsPerEvictionRun(int numTestsPerEvictionRun)
    Sets the max number of objects to examine during each run of the idle object evictor thread (if any).
    void
    setSoftMinEvictableIdleTimeMillis(long 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.
    void
    setTestOnBorrow(boolean testOnBorrow)
    When true, objects will be validated before being returned by the borrowObject() method.
    void
    setTestOnReturn(boolean testOnReturn)
    When true, objects will be validated before being returned to the pool within the returnObject(Object).
    void
    setTestWhileIdle(boolean testWhileIdle)
    When true, objects will be validated by the idle object evictor (if any).
    void
    setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis)
    Sets the number of milliseconds to sleep between runs of the idle object evictor thread.
    void
    setWhenExhaustedAction(byte whenExhaustedAction)
    Sets the action to take when the borrowObject() method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).

    Methods inherited from class org.apache.commons.pool.BaseObjectPool

    addObject, borrowObject, clear, close, getNumActive, getNumIdle, invalidateObject, returnObject, setFactory

    Field Details

    DEFAULT_MAX_ACTIVE

    public static final int DEFAULT_MAX_ACTIVE
    The default cap on the total number of active instances from the pool.
    Field Value:
    8

    DEFAULT_MAX_IDLE

    public static final int DEFAULT_MAX_IDLE
    The default cap on the number of "sleeping" instances in the pool.
    Field Value:
    8

    DEFAULT_MAX_WAIT

    public static final long DEFAULT_MAX_WAIT
    The default maximum amount of time (in millis) the borrowObject() method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK.
    Field Value:
    -1L

    DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS

    public static final long DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS
    Field Value:
    1800000L

    DEFAULT_MIN_IDLE

    public static final int DEFAULT_MIN_IDLE
    The default minimum number of "sleeping" instances in the pool before before the evictor thread (if active) spawns new objects.
    Field Value:
    0

    DEFAULT_NUM_TESTS_PER_EVICTION_RUN

    public static final int DEFAULT_NUM_TESTS_PER_EVICTION_RUN
    The default number of objects to examine per run in the idle object evictor.
    Field Value:
    3

    DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS

    public static final long DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS
    Field Value:
    -1L

    DEFAULT_TEST_ON_BORROW

    public static final boolean DEFAULT_TEST_ON_BORROW
    The default "test on borrow" value.
    Field Value:
    false

    DEFAULT_TEST_ON_RETURN

    public static final boolean DEFAULT_TEST_ON_RETURN
    The default "test on return" value.
    Field Value:
    false

    DEFAULT_TEST_WHILE_IDLE

    public static final boolean DEFAULT_TEST_WHILE_IDLE
    The default "test while idle" value.
    Field Value:
    false

    DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS

    public static final long DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS
    The default "time between eviction runs" value.
    Field Value:
    -1L

    DEFAULT_WHEN_EXHAUSTED_ACTION

    public static final byte DEFAULT_WHEN_EXHAUSTED_ACTION
    The default "when exhausted action" for the pool.
    Field Value:
    1

    WHEN_EXHAUSTED_BLOCK

    public static final byte WHEN_EXHAUSTED_BLOCK
    Field Value:
    1

    WHEN_EXHAUSTED_FAIL

    public static final byte WHEN_EXHAUSTED_FAIL
    Field Value:
    0

    WHEN_EXHAUSTED_GROW

    public static final byte WHEN_EXHAUSTED_GROW
    Field Value:
    2

    Constructor Details

    GenericObjectPool

    public GenericObjectPool()
    Create a new GenericObjectPool.

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see getWhenExhaustedAction())
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see getMaxWait())

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait,
                             boolean testOnBorrow,
                             boolean testOnReturn)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see getWhenExhaustedAction())
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see getMaxWait())
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject() method (see getTestOnBorrow())
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(Object) method (see getTestOnReturn())

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait,
                             int maxIdle)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see getWhenExhaustedAction())
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see getMaxWait())
    maxIdle - the maximum number of idle objects in my pool (see getMaxIdle())

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait,
                             int maxIdle,
                             boolean testOnBorrow,
                             boolean testOnReturn)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see getWhenExhaustedAction())
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see getMaxWait())
    maxIdle - the maximum number of idle objects in my pool (see getMaxIdle())
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject() method (see getTestOnBorrow())
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(Object) method (see getTestOnReturn())

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait,
                             int maxIdle,
                             boolean testOnBorrow,
                             boolean testOnReturn,
                             long timeBetweenEvictionRunsMillis,
                             int numTestsPerEvictionRun,
                             long minEvictableIdleTimeMillis,
                             boolean testWhileIdle)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see setWhenExhaustedAction(byte))
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject() method (see setTestOnBorrow(boolean))
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(Object) method (see setTestOnReturn(boolean))
    timeBetweenEvictionRunsMillis - the amount of time (in milliseconds) to sleep between examining idle objects for eviction (see setTimeBetweenEvictionRunsMillis(long))
    numTestsPerEvictionRun - the number of idle objects to examine per run within the idle object eviction thread (if any) (see setNumTestsPerEvictionRun(int))
    minEvictableIdleTimeMillis - the minimum number of milliseconds an object can sit idle in the pool before it is eligable for evcition (see setMinEvictableIdleTimeMillis(long))
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait,
                             int maxIdle,
                             int minIdle,
                             boolean testOnBorrow,
                             boolean testOnReturn,
                             long timeBetweenEvictionRunsMillis,
                             int numTestsPerEvictionRun,
                             long minEvictableIdleTimeMillis,
                             boolean testWhileIdle)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see setWhenExhaustedAction(byte))
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
    minIdle - the minimum number of idle objects in my pool (see setMinIdle(int))
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject() method (see setTestOnBorrow(boolean))
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(Object) method (see setTestOnReturn(boolean))
    timeBetweenEvictionRunsMillis - the amount of time (in milliseconds) to sleep between examining idle objects for eviction (see setTimeBetweenEvictionRunsMillis(long))
    numTestsPerEvictionRun - the number of idle objects to examine per run within the idle object eviction thread (if any) (see setNumTestsPerEvictionRun(int))
    minEvictableIdleTimeMillis - the minimum number of milliseconds an object can sit idle in the pool before it is eligable for evcition (see setMinEvictableIdleTimeMillis(long))
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             int maxActive,
                             byte whenExhaustedAction,
                             long maxWait,
                             int maxIdle,
                             int minIdle,
                             boolean testOnBorrow,
                             boolean testOnReturn,
                             long timeBetweenEvictionRunsMillis,
                             int numTestsPerEvictionRun,
                             long minEvictableIdleTimeMillis,
                             boolean testWhileIdle,
                             long softMinEvictableIdleTimeMillis)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    whenExhaustedAction - the action to take when the pool is exhausted (see setWhenExhaustedAction(byte))
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted an and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
    minIdle - the minimum number of idle objects in my pool (see setMinIdle(int))
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject() method (see setTestOnBorrow(boolean))
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(Object) method (see setTestOnReturn(boolean))
    timeBetweenEvictionRunsMillis - the amount of time (in milliseconds) to sleep between examining idle objects for eviction (see setTimeBetweenEvictionRunsMillis(long))
    numTestsPerEvictionRun - the number of idle objects to examine per run within the idle object eviction thread (if any) (see setNumTestsPerEvictionRun(int))
    minEvictableIdleTimeMillis - the minimum number of milliseconds an object can sit idle in the pool before it is eligable for evcition (see setMinEvictableIdleTimeMillis(long))
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))
    softMinEvictableIdleTimeMillis - the minimum number of milliseconds an object can sit idle in the pool before it is eligable for evcition with the extra condition that at least "minIdle" amount of object remain in the pool. (see setSoftMinEvictableIdleTimeMillis(long))

    GenericObjectPool

    public GenericObjectPool(PoolableObjectFactory factory,
                             GenericObjectPool.Config config)
    Create a new GenericObjectPool using the specified values.
    Parameters:
    factory - the (possibly null)PoolableObjectFactory to use to create, validate and destroy objects
    config - a non-null GenericObjectPool.Config describing my configuration

    Method Details

    addObject

    public void addObject()
                throws Exception
    Create an object, and place it into the pool. addObject() is useful for "pre-loading" a pool with idle objects.
    Specified by:
    addObject in interface ObjectPool
    Overrides:
    addObject in interface BaseObjectPool

    borrowObject

    public Object borrowObject()
                throws Exception
    Specified by:
    borrowObject in interface ObjectPool
    Overrides:
    borrowObject in interface BaseObjectPool

    clear

    public void clear()
    Specified by:
    clear in interface ObjectPool
    Overrides:
    clear in interface BaseObjectPool

    close

    public void close()
                throws Exception
    Specified by:
    close in interface ObjectPool
    Overrides:
    close in interface BaseObjectPool

    evict

    public void evict()
                throws Exception

    getMaxActive

    public int getMaxActive()
    Returns the cap on the total number of active instances from my pool.
    Returns:
    the cap on the total number of active instances from my pool.

    getMaxIdle

    public int getMaxIdle()
    Returns the cap on the number of "idle" instances in the pool.
    Returns:
    the cap on the number of "idle" instances in the pool.

    getMaxWait

    public long getMaxWait()
    Returns the maximum amount of time (in milliseconds) the borrowObject() method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK. When less than 0, the borrowObject() method may block indefinitely.

    getMinEvictableIdleTimeMillis

    public long getMinEvictableIdleTimeMillis()
    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).

    getMinIdle

    public int getMinIdle()
    Returns the minimum number of objects allowed in the pool before the evictor thread (if active) spawns new objects. (Note no objects are created when: numActive + numIdle >= maxActive)
    Returns:
    The minimum number of objects.

    getNumActive

    public int getNumActive()
    Specified by:
    getNumActive in interface ObjectPool
    Overrides:
    getNumActive in interface BaseObjectPool

    getNumIdle

    public int getNumIdle()
    Specified by:
    getNumIdle in interface ObjectPool
    Overrides:
    getNumIdle in interface BaseObjectPool

    getNumTestsPerEvictionRun

    public int getNumTestsPerEvictionRun()
    Returns the max number of objects to examine during each run of the idle object evictor thread (if any).

    getSoftMinEvictableIdleTimeMillis

    public long getSoftMinEvictableIdleTimeMillis()
    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.

    getTestOnBorrow

    public boolean getTestOnBorrow()
    When true, objects will be validated before being returned by the borrowObject() method. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.

    getTestOnReturn

    public boolean getTestOnReturn()
    When true, objects will be validated before being returned to the pool within the returnObject(Object).

    getTestWhileIdle

    public boolean getTestWhileIdle()
    When true, objects will be validated by the idle object evictor (if any). If an object fails to validate, it will be dropped from the pool.

    getTimeBetweenEvictionRunsMillis

    public long getTimeBetweenEvictionRunsMillis()
    Returns the number of milliseconds to sleep between runs of the idle object evictor thread. When non-positive, no idle object evictor thread will be run.

    getWhenExhaustedAction

    public byte getWhenExhaustedAction()
    Returns the action to take when the borrowObject() method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).

    invalidateObject

    public void invalidateObject(Object obj)
                throws Exception
    Specified by:
    invalidateObject in interface ObjectPool
    Overrides:
    invalidateObject in interface BaseObjectPool

    returnObject

    public void returnObject(Object obj)
                throws Exception
    Specified by:
    returnObject in interface ObjectPool
    Overrides:
    returnObject in interface BaseObjectPool

    setConfig

    public void setConfig(GenericObjectPool.Config conf)
    Sets my configuration.

    setFactory

    public void setFactory(PoolableObjectFactory factory)
                throws IllegalStateException
    Specified by:
    setFactory in interface ObjectPool
    Overrides:
    setFactory in interface BaseObjectPool

    setMaxActive

    public void setMaxActive(int maxActive)
    Sets the cap on the total number of active instances from my pool.
    Parameters:
    maxActive - The cap on the total number of active instances from my pool. Use a negative value for an infinite number of instances.

    setMaxIdle

    public void setMaxIdle(int maxIdle)
    Sets the cap on the number of "idle" instances in the pool.
    Parameters:
    maxIdle - The cap on the number of "idle" instances in the pool. Use a negative value to indicate an unlimited number of idle instances.

    setMaxWait

    public void setMaxWait(long maxWait)
    Sets the maximum amount of time (in milliseconds) the borrowObject() method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK. When less than 0, the borrowObject() method may block indefinitely.

    setMinEvictableIdleTimeMillis

    public void setMinEvictableIdleTimeMillis(long 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.

    setMinIdle

    public void setMinIdle(int minIdle)
    Sets the minimum number of objects allowed in the pool before the evictor thread (if active) spawns new objects. (Note no objects are created when: numActive + numIdle >= maxActive)
    Parameters:
    minIdle - The minimum number of objects.

    setNumTestsPerEvictionRun

    public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun)

    setSoftMinEvictableIdleTimeMillis

    public void setSoftMinEvictableIdleTimeMillis(long 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.

    setTestOnBorrow

    public void setTestOnBorrow(boolean testOnBorrow)
    When true, objects will be validated before being returned by the borrowObject() method. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.

    setTestOnReturn

    public void setTestOnReturn(boolean testOnReturn)
    When true, objects will be validated before being returned to the pool within the returnObject(Object).

    setTestWhileIdle

    public void setTestWhileIdle(boolean testWhileIdle)
    When true, objects will be validated by the idle object evictor (if any). If an object fails to validate, it will be dropped from the pool.

    setTimeBetweenEvictionRunsMillis

    public void setTimeBetweenEvictionRunsMillis(long timeBetweenEvictionRunsMillis)
    Sets the number of milliseconds to sleep between runs of the idle object evictor thread. When non-positive, no idle object evictor thread will be run.

    setWhenExhaustedAction

    public void setWhenExhaustedAction(byte whenExhaustedAction)
    Sets the action to take when the borrowObject() method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).
    Parameters:
    whenExhaustedAction - the action code, which must be one of WHEN_EXHAUSTED_BLOCK, WHEN_EXHAUSTED_FAIL, or WHEN_EXHAUSTED_GROW

    Copyright © 2001-2003 Apache Software Foundation. Documenation generated November 10 2006.