GenericKeyedObjectPool

java.lang.Object
- com.sh.pool.BaseKeyedObjectPool<K,V>
- - com.sh.pool.impl.GenericKeyedObjectPool<K,V>

所有已实现的接口:

KeyedObjectPool<K,V>
```
public class GenericKeyedObjectPool<K,V>
extends BaseKeyedObjectPool<K,V>
implements KeyedObjectPool<K,V>
```
Description: GenericKeyedObjectPool Title:首亨软件 - CRM、TSS、ERP等信息化管理软件

版本:

3.0

作者:

江兴春

嵌套类概要

嵌套类
限定符和类型类和说明

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

嵌套类
限定符和类型	类和说明
`static class`	`GenericKeyedObjectPool.Config` A simple "struct" encapsulating the configuration information for a `GenericKeyedObjectPool`.

字段概要

字段
限定符和类型	字段和说明
`static boolean`	`DEFAULT_LIFO` The default LIFO status.
`static int`	`DEFAULT_MAX_ACTIVE` The default cap on the total number of active instances (per key) from the pool.
`static int`	`DEFAULT_MAX_IDLE` The default cap on the number of idle instances (per key) in the pool.
`static int`	`DEFAULT_MAX_TOTAL` The default cap on the the overall maximum number of objects that can exist at one time.
`static long`	`DEFAULT_MAX_WAIT` The default maximum amount of time (in milliseconds) the `borrowObject(K)` 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 level of idle objects in the pool.
`static int`	`DEFAULT_NUM_TESTS_PER_EVICTION_RUN` The default number of objects to examine per run in the idle object evictor.
`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(K)` 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(K)` 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(K)` method should simply create a new object anyway.

构造器概要

构造器
构造器和说明
`GenericKeyedObjectPool()` Create a new `GenericKeyedObjectPool` with no factory.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, GenericKeyedObjectPool.Config config)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, boolean testOnBorrow, boolean testOnReturn)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle)` Create a new `GenericKeyedObjectPool` using the specified values.
`GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory, int maxActive, byte whenExhaustedAction, long maxWait, int maxIdle, int maxTotal, int minIdle, boolean testOnBorrow, boolean testOnReturn, long timeBetweenEvictionRunsMillis, int numTestsPerEvictionRun, long minEvictableIdleTimeMillis, boolean testWhileIdle, boolean lifo)` Create a new `GenericKeyedObjectPool` using the specified values.

方法概要

所有方法实例方法具体方法已过时的方法
限定符和类型	方法和说明
`void`	`addObject(K key)` Create an object using the `factory`, passivate it, and then place it in the idle object pool.
`V`	`borrowObject(K key)` Borrows an object from the keyed pool associated with the given key.
`void`	`clear()` Not supported in this base implementation.
`void`	`clear(K key)` Clears the specified pool, removing all pooled instances corresponding to the given `key`.
`void`	`clearOldest()` Clears oldest 15% of objects in pool.
`void`	`close()` Closes the keyed object pool.
`void`	`evict()` Perform `numTests` idle object eviction tests, evicting examined objects that meet the criteria for eviction.
`boolean`	`getLifo()` Whether or not the idle object pools act as LIFO queues.
`int`	`getMaxActive()` Returns the cap on the number of object instances allocated by the pool (checked out or idle), per key.
`int`	`getMaxIdle()` Returns the cap on the number of "idle" instances per key.
`int`	`getMaxTotal()` Returns the overall maximum number of objects (across pools) that can exist at one time.
`long`	`getMaxWait()` Returns the maximum amount of time (in milliseconds) the `borrowObject(K)` 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 eligible for eviction by the idle object evictor (if any).
`int`	`getMinIdle()`
`int`	`getNumActive()` Returns the total number of instances current borrowed from this pool but not yet returned.
`int`	`getNumActive(java.lang.Object key)` Returns the number of instances currently borrowed from but not yet returned to the pool corresponding to the given `key`.
`int`	`getNumIdle()` Returns the total number of instances currently idle in this pool.
`int`	`getNumIdle(java.lang.Object key)` Returns the number of instances corresponding to the given `key` currently idle in this pool.
`int`	`getNumTestsPerEvictionRun()` Returns the max number of objects to examine during each run of the idle object evictor thread (if any).
`boolean`	`getTestOnBorrow()` When `true`, objects will be `validated` before being returned by the `borrowObject(K)` method.
`boolean`	`getTestOnReturn()` When `true`, objects will be `validated` before being returned to the pool within the `returnObject(K, V)`.
`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(K)` method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).
`void`	`invalidateObject(K key, V obj)` Invalidates an object from the pool.
`void`	`preparePool(K key, boolean populateImmediately)`
`void`	`returnObject(K key, V obj)` Returns an object to a keyed pool.
`void`	`setConfig(GenericKeyedObjectPool.Config conf)` Sets the configuration.
`void`	`setFactory(KeyedPoolableObjectFactory<K,V> factory)` 已过时。 to be removed in version 2.0
`void`	`setLifo(boolean lifo)` Sets the LIFO property of the pools.
`void`	`setMaxActive(int maxActive)` Sets the cap on the number of object instances managed by the pool per key.
`void`	`setMaxIdle(int maxIdle)` Sets the cap on the number of "idle" instances in the pool.
`void`	`setMaxTotal(int maxTotal)` Sets the cap on the total number of instances from all pools combined.
`void`	`setMaxWait(long maxWait)` Sets the maximum amount of time (in milliseconds) the `borrowObject(K)` 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 eligible for eviction by the idle object evictor (if any).
`void`	`setMinIdle(int poolSize)`
`void`	`setNumTestsPerEvictionRun(int numTestsPerEvictionRun)` Sets the max number of objects to examine during each run of the idle object evictor thread (if any).
`void`	`setTestOnBorrow(boolean testOnBorrow)` When `true`, objects will be `validated` before being returned by the `borrowObject(K)` method.
`void`	`setTestOnReturn(boolean testOnReturn)` When `true`, objects will be `validated` before being returned to the pool within the `returnObject(K, V)`.
`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(K)` method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).

从类继承的方法 java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - WHEN_EXHAUSTED_FAIL
```
public static final 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(K) method should fail, throwing a NoSuchElementException.
    
    另请参阅:
    
    WHEN_EXHAUSTED_BLOCK, WHEN_EXHAUSTED_GROW, setWhenExhaustedAction(byte), 常量字段值
  - WHEN_EXHAUSTED_BLOCK
```
public static final 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(K) method should block until a new object is available, or the maximum wait time has been reached.
    
    另请参阅:
    
    WHEN_EXHAUSTED_FAIL, WHEN_EXHAUSTED_GROW, setMaxWait(long), getMaxWait(), setWhenExhaustedAction(byte), 常量字段值
  - WHEN_EXHAUSTED_GROW
```
public static final 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(K) method should simply create a new object anyway.
    
    另请参阅:
    
    WHEN_EXHAUSTED_FAIL, WHEN_EXHAUSTED_GROW, setWhenExhaustedAction(byte), 常量字段值
  - DEFAULT_MAX_IDLE
```
public static final int DEFAULT_MAX_IDLE
```
    The default cap on the number of idle instances (per key) in the pool.
    
    另请参阅:
    
    getMaxIdle(), setMaxIdle(int), 常量字段值
  - DEFAULT_MAX_ACTIVE
```
public static final int DEFAULT_MAX_ACTIVE
```
    The default cap on the total number of active instances (per key) from the pool.
    
    另请参阅:
    
    getMaxActive(), setMaxActive(int), 常量字段值
  - DEFAULT_MAX_TOTAL
```
public static final int DEFAULT_MAX_TOTAL
```
    The default cap on the the overall maximum number of objects that can exist at one time.
    
    另请参阅:
    
    getMaxTotal(), setMaxTotal(int), 常量字段值
  - DEFAULT_WHEN_EXHAUSTED_ACTION
```
public static final byte DEFAULT_WHEN_EXHAUSTED_ACTION
```
    The default "when exhausted action" for the pool.
    
    另请参阅:
    
    WHEN_EXHAUSTED_BLOCK, WHEN_EXHAUSTED_FAIL, WHEN_EXHAUSTED_GROW, setWhenExhaustedAction(byte), 常量字段值
  - DEFAULT_MAX_WAIT
```
public static final long DEFAULT_MAX_WAIT
```
    The default maximum amount of time (in milliseconds) the borrowObject(K) method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK.
    
    另请参阅:
    
    getMaxWait(), setMaxWait(long), 常量字段值
  - DEFAULT_TEST_ON_BORROW
```
public static final boolean DEFAULT_TEST_ON_BORROW
```
    The default "test on borrow" value.
    
    另请参阅:
    
    getTestOnBorrow(), setTestOnBorrow(boolean), 常量字段值
  - DEFAULT_TEST_ON_RETURN
```
public static final boolean DEFAULT_TEST_ON_RETURN
```
    The default "test on return" value.
    
    另请参阅:
    
    getTestOnReturn(), setTestOnReturn(boolean), 常量字段值
  - DEFAULT_TEST_WHILE_IDLE
```
public static final boolean DEFAULT_TEST_WHILE_IDLE
```
    The default "test while idle" value.
    
    另请参阅:
    
    getTestWhileIdle(), setTestWhileIdle(boolean), getTimeBetweenEvictionRunsMillis(), setTimeBetweenEvictionRunsMillis(long), 常量字段值
  - DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS
```
public static final long DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS
```
    The default "time between eviction runs" value.
    
    另请参阅:
    
    getTimeBetweenEvictionRunsMillis(), setTimeBetweenEvictionRunsMillis(long), 常量字段值
  - 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.
    
    另请参阅:
    
    getNumTestsPerEvictionRun(), setNumTestsPerEvictionRun(int), getTimeBetweenEvictionRunsMillis(), setTimeBetweenEvictionRunsMillis(long), 常量字段值
  - DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS
```
public static final long DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS
```
    The default value for getMinEvictableIdleTimeMillis().
    
    另请参阅:
    
    getMinEvictableIdleTimeMillis(), setMinEvictableIdleTimeMillis(long), 常量字段值
  - DEFAULT_MIN_IDLE
```
public static final int DEFAULT_MIN_IDLE
```
    The default minimum level of idle objects in the pool.
    
    从以下版本开始:
    
    Pool 1.3
    
    另请参阅:
    
    setMinIdle(int), getMinIdle(), 常量字段值
  - DEFAULT_LIFO
```
public static final boolean DEFAULT_LIFO
```
    The default LIFO status. True means that borrowObject returns the most recently used ("last in") idle object in a pool (if there are idle instances available). False means that pools behave as FIFO queues - objects are taken from idle object pools in the order that they are returned.
    
    另请参阅:
    
    setLifo(boolean), 常量字段值
- 构造器详细资料
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool()
```
    Create a new GenericKeyedObjectPool with no factory.
    
    另请参阅:
    
    GenericKeyedObjectPool(KeyedPoolableObjectFactory), setFactory(KeyedPoolableObjectFactory)
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              GenericKeyedObjectPool.Config config)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    config - a non-null GenericKeyedObjectPool.Config describing the configuration
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    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 and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              boolean testOnBorrow,
                              boolean testOnReturn)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    maxActive - the maximum number of objects that can be borrowed from me at one time (see setMaxActive(int))
    
    maxWait - the maximum amount of time to wait for an idle object when the pool is exhausted and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    
    whenExhaustedAction - the action to take when the pool is exhausted (see setWhenExhaustedAction(byte))
    
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject(K) method (see setTestOnBorrow(boolean))
    
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(K, V) method (see setTestOnReturn(boolean))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              int maxIdle)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    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 and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              int maxIdle,
                              boolean testOnBorrow,
                              boolean testOnReturn)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    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 and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see getMaxWait())
    
    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(K) method (see setTestOnBorrow(boolean))
    
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(K, V) method (see setTestOnReturn(boolean))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              int maxIdle,
                              boolean testOnBorrow,
                              boolean testOnReturn,
                              long timeBetweenEvictionRunsMillis,
                              int numTestsPerEvictionRun,
                              long minEvictableIdleTimeMillis,
                              boolean testWhileIdle)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    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 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(K) method (see setTestOnBorrow(boolean))
    
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(K, V) 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 eligible for eviction (see setMinEvictableIdleTimeMillis(long))
    
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              int maxIdle,
                              int maxTotal,
                              boolean testOnBorrow,
                              boolean testOnReturn,
                              long timeBetweenEvictionRunsMillis,
                              int numTestsPerEvictionRun,
                              long minEvictableIdleTimeMillis,
                              boolean testWhileIdle)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    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 and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
    
    maxTotal - the maximum number of objects that can exists at one time (see setMaxTotal(int))
    
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject(K) method (see setTestOnBorrow(boolean))
    
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(K, V) 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 eligible for eviction (see setMinEvictableIdleTimeMillis(long))
    
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              int maxIdle,
                              int maxTotal,
                              int minIdle,
                              boolean testOnBorrow,
                              boolean testOnReturn,
                              long timeBetweenEvictionRunsMillis,
                              int numTestsPerEvictionRun,
                              long minEvictableIdleTimeMillis,
                              boolean testWhileIdle)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    maxActive - the maximum number of objects that can be borrowed 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 and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
    
    maxTotal - the maximum number of objects that can exists at one time (see setMaxTotal(int))
    
    minIdle - the minimum number of idle objects to have in the pool at any one time (see setMinIdle(int))
    
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject(K) method (see setTestOnBorrow(boolean))
    
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(K, V) 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 eligible for eviction (see setMinEvictableIdleTimeMillis(long))
    
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))
    
    从以下版本开始:
    
    Pool 1.3
  - GenericKeyedObjectPool
```
public GenericKeyedObjectPool(KeyedPoolableObjectFactory<K,V> factory,
                              int maxActive,
                              byte whenExhaustedAction,
                              long maxWait,
                              int maxIdle,
                              int maxTotal,
                              int minIdle,
                              boolean testOnBorrow,
                              boolean testOnReturn,
                              long timeBetweenEvictionRunsMillis,
                              int numTestsPerEvictionRun,
                              long minEvictableIdleTimeMillis,
                              boolean testWhileIdle,
                              boolean lifo)
```
    Create a new GenericKeyedObjectPool using the specified values.
    
    参数:
    
    factory - the KeyedPoolableObjectFactory to use to create, validate, and destroy objects if not null
    
    maxActive - the maximum number of objects that can be borrowed 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 and whenExhaustedAction is WHEN_EXHAUSTED_BLOCK (otherwise ignored) (see setMaxWait(long))
    
    maxIdle - the maximum number of idle objects in my pool (see setMaxIdle(int))
    
    maxTotal - the maximum number of objects that can exists at one time (see setMaxTotal(int))
    
    minIdle - the minimum number of idle objects to have in the pool at any one time (see setMinIdle(int))
    
    testOnBorrow - whether or not to validate objects before they are returned by the borrowObject(K) method (see setTestOnBorrow(boolean))
    
    testOnReturn - whether or not to validate objects after they are returned to the returnObject(K, V) 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 eligible for eviction (see setMinEvictableIdleTimeMillis(long))
    
    testWhileIdle - whether or not to validate objects in the idle object eviction thread, if any (see setTestWhileIdle(boolean))
    
    lifo - whether or not the pools behave as LIFO (last in first out) queues (see setLifo(boolean))
    
    从以下版本开始:
    
    Pool 1.4
- 方法详细资料
  - getMaxActive
```
public int getMaxActive()
```
    Returns the cap on the number of object instances allocated by the pool (checked out or idle), per key. A negative value indicates no limit.
    
    返回:
    
    the cap on the number of active instances per key.
    
    另请参阅:
    
    setMaxActive(int)
  - setMaxActive
```
public void setMaxActive(int maxActive)
```
    Sets the cap on the number of object instances managed by the pool per key.
    
    参数:
    
    maxActive - The cap on the number of object instances per key. Use a negative value for no limit.
    
    另请参阅:
    
    getMaxActive()
  - getMaxTotal
```
public int getMaxTotal()
```
    Returns the overall maximum number of objects (across pools) that can exist at one time. A negative value indicates no limit.
    
    返回:
    
    the maximum number of instances in circulation at one time.
    
    另请参阅:
    
    setMaxTotal(int)
  - setMaxTotal
```
public void setMaxTotal(int maxTotal)
```
    Sets the cap on the total number of instances from all pools combined. When maxTotal is set to a positive value and borrowObject is invoked when at the limit with no idle instances available, an attempt is made to create room by clearing the oldest 15% of the elements from the keyed pools.
    
    参数:
    
    maxTotal - The cap on the total number of instances across pools. Use a negative value for no limit.
    
    另请参阅:
    
    getMaxTotal()
  - getWhenExhaustedAction
```
public byte getWhenExhaustedAction()
```
    Returns the action to take when the borrowObject(K) method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).
    
    返回:
    
    one of WHEN_EXHAUSTED_BLOCK, WHEN_EXHAUSTED_FAIL or WHEN_EXHAUSTED_GROW
    
    另请参阅:
    
    setWhenExhaustedAction(byte)
  - setWhenExhaustedAction
```
public void setWhenExhaustedAction(byte whenExhaustedAction)
```
    Sets the action to take when the borrowObject(K) method is invoked when the pool is exhausted (the maximum number of "active" objects has been reached).
    
    参数:
    
    whenExhaustedAction - the action code, which must be one of WHEN_EXHAUSTED_BLOCK, WHEN_EXHAUSTED_FAIL, or WHEN_EXHAUSTED_GROW
    
    另请参阅:
    
    getWhenExhaustedAction()
  - getMaxWait
```
public long getMaxWait()
```
    Returns the maximum amount of time (in milliseconds) the borrowObject(K) method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK. When less than or equal to 0, the borrowObject(K) method may block indefinitely.
    
    返回:
    
    the maximum number of milliseconds borrowObject will block.
    
    另请参阅:
    
    setMaxWait(long), setWhenExhaustedAction(byte), WHEN_EXHAUSTED_BLOCK
  - setMaxWait
```
public void setMaxWait(long maxWait)
```
    Sets the maximum amount of time (in milliseconds) the borrowObject(K) method should block before throwing an exception when the pool is exhausted and the "when exhausted" action is WHEN_EXHAUSTED_BLOCK. When less than or equal to 0, the borrowObject(K) method may block indefinitely.
    
    参数:
    
    maxWait - the maximum number of milliseconds borrowObject will block or negative for indefinitely.
    
    另请参阅:
    
    getMaxWait(), setWhenExhaustedAction(byte), WHEN_EXHAUSTED_BLOCK
  - getMaxIdle
```
public int getMaxIdle()
```
    Returns the cap on the number of "idle" instances per key.
    
    返回:
    
    the maximum number of "idle" instances that can be held in a given keyed pool.
    
    另请参阅:
    
    setMaxIdle(int)
  - setMaxIdle
```
public void setMaxIdle(int maxIdle)
```
    Sets the cap on the number of "idle" instances in the pool. If maxIdle is set too low on heavily loaded systems it is possible you will see objects being destroyed and almost immediately new objects being created. This is a result of the active threads momentarily returning objects faster than they are requesting them them, causing the number of idle objects to rise above maxIdle. The best value for maxIdle for heavily loaded system will vary but the default is a good starting point.
    
    参数:
    
    maxIdle - the maximum number of "idle" instances that can be held in a given keyed pool. Use a negative value for no limit.
    
    另请参阅:
    
    getMaxIdle(), DEFAULT_MAX_IDLE
  - setMinIdle
```
public void setMinIdle(int poolSize)
```
  - getMinIdle
```
public int getMinIdle()
```
  - getTestOnBorrow
```
public boolean getTestOnBorrow()
```
    When true, objects will be validated before being returned by the borrowObject(K) method. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.
    
    返回:
    
    true if objects are validated before being borrowed.
    
    另请参阅:
    
    setTestOnBorrow(boolean)
  - setTestOnBorrow
```
public void setTestOnBorrow(boolean testOnBorrow)
```
    When true, objects will be validated before being returned by the borrowObject(K) method. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another.
    
    参数:
    
    testOnBorrow - whether object should be validated before being returned by borrowObject.
    
    另请参阅:
    
    getTestOnBorrow()
  - getTestOnReturn
```
public boolean getTestOnReturn()
```
    When true, objects will be validated before being returned to the pool within the returnObject(K, V).
    
    返回:
    
    true when objects will be validated before being returned.
    
    另请参阅:
    
    setTestOnReturn(boolean)
  - setTestOnReturn
```
public void setTestOnReturn(boolean testOnReturn)
```
    When true, objects will be validated before being returned to the pool within the returnObject(K, V).
    
    参数:
    
    testOnReturn - true so objects will be validated before being returned.
    
    另请参阅:
    
    getTestOnReturn()
  - 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.
    
    返回:
    
    milliseconds to sleep between evictor runs.
    
    另请参阅:
    
    setTimeBetweenEvictionRunsMillis(long)
  - 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.
    
    参数:
    
    timeBetweenEvictionRunsMillis - milliseconds to sleep between evictor runs.
    
    另请参阅:
    
    getTimeBetweenEvictionRunsMillis()
  - getNumTestsPerEvictionRun
```
public int getNumTestsPerEvictionRun()
```
    Returns the max number of objects to examine during each run of the idle object evictor thread (if any).
    
    返回:
    
    number of objects to examine each eviction run.
    
    另请参阅:
    
    setNumTestsPerEvictionRun(int), setTimeBetweenEvictionRunsMillis(long)
  - setNumTestsPerEvictionRun
```
public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun)
```
    Sets the max number of objects to examine during each run of the idle object evictor thread (if any).
    When a negative value is supplied, ceil(getNumIdle())/abs(getNumTestsPerEvictionRun()) tests will be run. I.e., when the value is -n, roughly one nth of the idle objects will be tested per run. When the value is positive, the number of tests actually performed in each run will be the minimum of this value and the number of instances idle in the pools.
    
    参数:
    
    numTestsPerEvictionRun - number of objects to examine each eviction run.
    
    另请参阅:
    
    setNumTestsPerEvictionRun(int), setTimeBetweenEvictionRunsMillis(long)
  - getMinEvictableIdleTimeMillis
```
public long getMinEvictableIdleTimeMillis()
```
    Returns the minimum amount of time an object may sit idle in the pool before it is eligible for eviction by the idle object evictor (if any).
    
    返回:
    
    minimum amount of time an object may sit idle in the pool before it is eligible for eviction.
    
    另请参阅:
    
    setMinEvictableIdleTimeMillis(long), setTimeBetweenEvictionRunsMillis(long)
  - setMinEvictableIdleTimeMillis
```
public void setMinEvictableIdleTimeMillis(long minEvictableIdleTimeMillis)
```
    Sets the minimum amount of time an object may sit idle in the pool before it is eligible 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.
    
    参数:
    
    minEvictableIdleTimeMillis - minimum amount of time an object may sit idle in the pool before it is eligible for eviction.
    
    另请参阅:
    
    getMinEvictableIdleTimeMillis(), setTimeBetweenEvictionRunsMillis(long)
  - 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.
    
    返回:
    
    true when objects are validated when borrowed.
    
    另请参阅:
    
    setTestWhileIdle(boolean), setTimeBetweenEvictionRunsMillis(long)
  - 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.
    
    参数:
    
    testWhileIdle - true so objects are validated when borrowed.
    
    另请参阅:
    
    getTestWhileIdle(), setTimeBetweenEvictionRunsMillis(long)
  - setConfig
```
public void setConfig(GenericKeyedObjectPool.Config conf)
```
    Sets the configuration.
    
    参数:
    
    conf - the new configuration to use.
    
    另请参阅:
    
    GenericKeyedObjectPool.Config
  - getLifo
```
public boolean getLifo()
```
    Whether or not the idle object pools act as LIFO queues. True means that borrowObject returns the most recently used ("last in") idle object in a pool (if there are idle instances available). False means that the pools behave as FIFO queues - objects are taken from idle object pools in the order that they are returned.
    
    返回:
    
    true if the pools are configured to act as LIFO queues
    
    从以下版本开始:
    
    1.4
  - setLifo
```
public void setLifo(boolean lifo)
```
    Sets the LIFO property of the pools. True means that borrowObject returns the most recently used ("last in") idle object in a pool (if there are idle instances available). False means that the pools behave as FIFO queues - objects are taken from idle object pools in the order that they are returned.
    
    参数:
    
    lifo - the new value for the lifo property
    
    从以下版本开始:
    
    1.4
  - borrowObject
```
public V borrowObject(K key)
               throws java.lang.Exception
```
    Borrows an object from the keyed pool associated with the given key.
    
    If there is an idle instance available in the pool associated with the given key, then either the most-recently returned (if lifo == true) or "oldest" (lifo == false) instance sitting idle in the pool will be activated and returned. If activation fails, or testOnBorrow is set to true and validation fails, the instance is destroyed and the next available instance is examined. This continues until either a valid instance is returned or there are no more idle instances available.
    
    If there are no idle instances available in the pool associated with the given key, behavior depends on the maxActive, maxTotal, and (if applicable) whenExhaustedAction and maxWait properties. If the number of instances checked out from the pool under the given key is less than maxActive and the total number of instances in circulation (under all keys) is less than maxTotal, a new instance is created, activated and (if applicable) validated and returned to the caller.
    
    If the associated keyed pool is exhausted (no available idle instances and no capacity to create new ones), this method will either block (WHEN_EXHAUSTED_BLOCK), throw a NoSuchElementException (WHEN_EXHAUSTED_FAIL), or grow (WHEN_EXHAUSTED_GROW - ignoring maxActive, maxTotal properties). The length of time that this method will block when whenExhaustedAction == WHEN_EXHAUSTED_BLOCK is determined by the maxWait property.
    
    When the pool is exhausted, multiple calling threads may be simultaneously blocked waiting for instances to become available. As of pool 1.5, a "fairness" algorithm has been implemented to ensure that threads receive available instances in request arrival order.
    
    指定者:
    
    borrowObject 在接口中 KeyedObjectPool<K,V>
    
    指定者:
    
    borrowObject 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - pool key
    
    返回:
    
    object instance from the keyed pool
    
    抛出:
    
    java.util.NoSuchElementException - if a keyed object instance cannot be returned.
    
    java.lang.IllegalStateException - after close has been called on this pool
    
    java.lang.Exception - when makeObject throws an exception
  - clear
```
public void clear()
```
    从类复制的说明: BaseKeyedObjectPool
    
    Not supported in this base implementation.
    
    指定者:
    
    clear 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    clear 在类中 BaseKeyedObjectPool<K,V>
  - clearOldest
```
public void clearOldest()
```
    Clears oldest 15% of objects in pool. The method sorts the objects into a TreeMap and then iterates the first 15% for removal.
    
    从以下版本开始:
    
    Pool 1.3
  - clear
```
public void clear(K key)
```
    Clears the specified pool, removing all pooled instances corresponding to the given key.
    
    指定者:
    
    clear 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    clear 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - the key to clear
  - getNumActive
```
public int getNumActive()
```
    Returns the total number of instances current borrowed from this pool but not yet returned.
    
    指定者:
    
    getNumActive 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    getNumActive 在类中 BaseKeyedObjectPool<K,V>
    
    返回:
    
    the total number of instances currently borrowed from this pool
  - getNumIdle
```
public int getNumIdle()
```
    Returns the total number of instances currently idle in this pool.
    
    指定者:
    
    getNumIdle 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    getNumIdle 在类中 BaseKeyedObjectPool<K,V>
    
    返回:
    
    the total number of instances currently idle in this pool
  - getNumActive
```
public int getNumActive(java.lang.Object key)
```
    Returns the number of instances currently borrowed from but not yet returned to the pool corresponding to the given key.
    
    指定者:
    
    getNumActive 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    getNumActive 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - the key to query
    
    返回:
    
    the number of instances corresponding to the given key currently borrowed in this pool
  - getNumIdle
```
public int getNumIdle(java.lang.Object key)
```
    Returns the number of instances corresponding to the given key currently idle in this pool.
    
    指定者:
    
    getNumIdle 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    getNumIdle 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - the key to query
    
    返回:
    
    the number of instances corresponding to the given key currently idle in this pool
  - returnObject
```
public void returnObject(K key,
                         V obj)
                  throws java.lang.Exception
```
    Returns an object to a keyed pool.
    
    For the pool to function correctly, the object instance must have been borrowed from the pool (under the same key) and not yet returned. Repeated returnObject calls on the same object/key pair (with no borrowObject calls in between) will result in multiple references to the object in the idle instance pool.
    
    If maxIdle is set to a positive value and the number of idle instances under the given key has reached this value, the returning instance is destroyed.
    
    If testOnReturn == true, the returning instance is validated before being returned to the idle instance pool under the given key. In this case, if validation fails, the instance is destroyed.
    
    指定者:
    
    returnObject 在接口中 KeyedObjectPool<K,V>
    
    指定者:
    
    returnObject 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - pool key
    
    obj - instance to return to the keyed pool
    
    抛出:
    
    java.lang.Exception - Exception
  - invalidateObject
```
public void invalidateObject(K key,
                             V obj)
                      throws java.lang.Exception
```
    Invalidates an object from the pool.
    
    By contract, obj must have been obtained using borrowObject using a key that is equivalent to the one used to borrow the Object in the first place.
    
    This method should be used when an object that has been borrowed is determined (due to an exception or other problem) to be invalid.
    
    Activation of this method decrements the active count associated with the given keyed pool and attempts to destroy obj.
    
    指定者:
    
    invalidateObject 在接口中 KeyedObjectPool<K,V>
    
    指定者:
    
    invalidateObject 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - pool key
    
    obj - instance to invalidate
    
    抛出:
    
    java.lang.Exception - if an exception occurs destroying the object
  - addObject
```
public void addObject(K key)
               throws java.lang.Exception
```
    Create an object using the factory, passivate it, and then place it in the idle object pool. addObject is useful for "pre-loading" a pool with idle objects.
    
    指定者:
    
    addObject 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    addObject 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    key - the key a new instance should be added to
    
    抛出:
    
    java.lang.Exception - when KeyedPoolableObjectFactory.makeObject(K) fails.
    
    java.lang.IllegalStateException - when no factory has been set or after close() has been called on this pool.
  - preparePool
```
public void preparePool(K key,
                        boolean populateImmediately)
```
  - close
```
public void close()
           throws java.lang.Exception
```
    Closes the keyed object pool. Once the pool is closed, borrowObject(Object) will fail with IllegalStateException, but returnObject(Object, Object) and invalidateObject(Object, Object) will continue to work, with returned objects destroyed on return.
    
    Destroys idle instances in the pool by invoking clear().
    
    指定者:
    
    close 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    close 在类中 BaseKeyedObjectPool<K,V>
    
    抛出:
    
    java.lang.Exception - Exception
  - setFactory
```
@Deprecated
public void setFactory(KeyedPoolableObjectFactory<K,V> factory)
                             throws java.lang.IllegalStateException
```
    已过时。 to be removed in version 2.0
    
    Sets the keyed poolable object factory associated with this pool.
    
    If this method is called when objects are checked out of any of the keyed pools, an IllegalStateException is thrown. Calling this method also has the side effect of destroying any idle instances in existing keyed pools, using the original factory.
    
    指定者:
    
    setFactory 在接口中 KeyedObjectPool<K,V>
    
    覆盖:
    
    setFactory 在类中 BaseKeyedObjectPool<K,V>
    
    参数:
    
    factory - KeyedPoolableObjectFactory to use when creating keyed object pool instances
    
    抛出:
    
    java.lang.IllegalStateException - if there are active (checked out) instances associated with this keyed object pool
  - evict
```
public void evict()
           throws java.lang.Exception
```
    Perform numTests idle object eviction tests, evicting examined objects that meet the criteria for eviction. If testWhileIdle is true, examined objects are validated when visited (and removed if invalid); otherwise only objects that have been idle for more than minEvicableIdletimeMillis are removed.
    
    Successive activations of this method examine objects in keyed pools in sequence, cycling through the keys and examining objects in oldest-to-youngest order within the keyed pools.
    
    抛出:
    
    java.lang.Exception - when there is a problem evicting idle objects.

类 GenericKeyedObjectPool<K,V>

嵌套类概要

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

WHEN_EXHAUSTED_FAIL

WHEN_EXHAUSTED_BLOCK

WHEN_EXHAUSTED_GROW

DEFAULT_MAX_IDLE

DEFAULT_MAX_ACTIVE

DEFAULT_MAX_TOTAL

DEFAULT_WHEN_EXHAUSTED_ACTION

DEFAULT_MAX_WAIT

DEFAULT_TEST_ON_BORROW

DEFAULT_TEST_ON_RETURN

DEFAULT_TEST_WHILE_IDLE

DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS

DEFAULT_NUM_TESTS_PER_EVICTION_RUN

DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS

DEFAULT_MIN_IDLE

DEFAULT_LIFO

构造器详细资料

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

GenericKeyedObjectPool

方法详细资料

getMaxActive

setMaxActive

getMaxTotal

setMaxTotal

getWhenExhaustedAction

setWhenExhaustedAction

getMaxWait

setMaxWait

getMaxIdle

setMaxIdle

setMinIdle

getMinIdle

getTestOnBorrow

setTestOnBorrow

getTestOnReturn

setTestOnReturn

getTimeBetweenEvictionRunsMillis

setTimeBetweenEvictionRunsMillis

getNumTestsPerEvictionRun

setNumTestsPerEvictionRun

getMinEvictableIdleTimeMillis

setMinEvictableIdleTimeMillis

getTestWhileIdle

setTestWhileIdle

setConfig

getLifo

setLifo

borrowObject

clear

clearOldest

clear

getNumActive

getNumIdle

getNumActive

getNumIdle

returnObject

invalidateObject

addObject

preparePool

close

setFactory

evict