Class PoolUtils
- Since:
- 2.0
-
Constructor Summary
ConstructorDescriptionPoolUtils instances should NOT be constructed in standard programming. -
Method Summary
Modifier and TypeMethodDescriptioncheckMinIdle
(KeyedObjectPool<K, V> keyedPool, Collection<K> keys, int minIdle, long periodMillis) Periodically check the idle object count for each key in theCollection keys
in the keyedPool.static <K,
V> TimerTask checkMinIdle
(KeyedObjectPool<K, V> keyedPool, K key, int minIdle, long periodMillis) Periodically check the idle object count for the key in the keyedPool.static <T> TimerTask
checkMinIdle
(ObjectPool<T> pool, int minIdle, long periodMillis) Periodically check the idle object count for the pool.static void
Should the supplied Throwable be re-thrown (eg if it is an instance of one of the Throwables that should never be swallowed).static <K,
V> KeyedObjectPool <K, V> erodingPool
(KeyedObjectPool<K, V> keyedPool) Returns a pool that adaptively decreases its size when idle objects are no longer needed.static <K,
V> KeyedObjectPool <K, V> erodingPool
(KeyedObjectPool<K, V> keyedPool, float factor) Returns a pool that adaptively decreases its size when idle objects are no longer needed.static <K,
V> KeyedObjectPool <K, V> erodingPool
(KeyedObjectPool<K, V> keyedPool, float factor, boolean perKey) Returns a pool that adaptively decreases its size when idle objects are no longer needed.static <T> ObjectPool
<T> erodingPool
(ObjectPool<T> pool) Returns a pool that adaptively decreases its size when idle objects are no longer needed.static <T> ObjectPool
<T> erodingPool
(ObjectPool<T> pool, float factor) Returns a pool that adaptively decreases its size when idle objects are no longer needed.static <K,
V> void prefill
(KeyedObjectPool<K, V> keyedPool, Collection<K> keys, int count) Deprecated.static <K,
V> void prefill
(KeyedObjectPool<K, V> keyedPool, K key, int count) Deprecated.static <T> void
prefill
(ObjectPool<T> pool, int count) Deprecated.static <K,
V> KeyedPooledObjectFactory <K, V> synchronizedKeyedPooledFactory
(KeyedPooledObjectFactory<K, V> keyedFactory) Returns a synchronized (thread-safe) KeyedPooledObjectFactory backed by the specified KeyedPooledObjectFactory.static <K,
V> KeyedObjectPool <K, V> synchronizedPool
(KeyedObjectPool<K, V> keyedPool) Returns a synchronized (thread-safe) KeyedObjectPool backed by the specified KeyedObjectPool.static <T> ObjectPool
<T> synchronizedPool
(ObjectPool<T> pool) Returns a synchronized (thread-safe) ObjectPool backed by the specified ObjectPool.static <T> PooledObjectFactory
<T> synchronizedPooledFactory
(PooledObjectFactory<T> factory) Returns a synchronized (thread-safe) PooledObjectFactory backed by the specified PooledObjectFactory.
-
Constructor Details
-
PoolUtils
public PoolUtils()PoolUtils instances should NOT be constructed in standard programming. Instead, the class should be used procedurally: PoolUtils.adapt(aPool);. This constructor is public to permit tools that require a JavaBean instance to operate.
-
-
Method Details
-
checkMinIdle
public static <K,V> Map<K,TimerTask> checkMinIdle(KeyedObjectPool<K, V> keyedPool, Collection<K> keys, int minIdle, long periodMillis) throws IllegalArgumentExceptionPeriodically check the idle object count for each key in theCollection keys
in the keyedPool. At most one idle object will be added per period.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the keyedPool to check periodically.keys
- a collection of keys to check the idle object count.minIdle
- if theKeyedObjectPool.getNumIdle(Object)
is less than this then add an idle object.periodMillis
- the frequency in milliseconds to check the number of idle objects in a keyedPool, seeTimer.schedule(TimerTask, long, long)
.- Returns:
- a
Map
of key andTimerTask
pairs that will periodically check the pools idle object count. - Throws:
IllegalArgumentException
- whenkeyedPool
,keys
, or any of the values in the collection isnull
or whenminIdle
is negative or whenperiod
isn't valid forTimer.schedule(TimerTask, long, long)
.- See Also:
-
checkMinIdle
public static <K,V> TimerTask checkMinIdle(KeyedObjectPool<K, V> keyedPool, K key, int minIdle, long periodMillis) throws IllegalArgumentExceptionPeriodically check the idle object count for the key in the keyedPool. At most one idle object will be added per period. If there is an exception when callingKeyedObjectPool.addObject(Object)
then no more checks for that key will be performed.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the keyedPool to check periodically.key
- the key to check the idle count of.minIdle
- if theKeyedObjectPool.getNumIdle(Object)
is less than this then add an idle object.periodMillis
- the frequency in milliseconds to check the number of idle objects in a keyedPool, seeTimer.schedule(TimerTask, long, long)
.- Returns:
- the
TimerTask
that will periodically check the pools idle object count. - Throws:
IllegalArgumentException
- whenkeyedPool
,key
isnull
or whenminIdle
is negative or whenperiod
isn't valid forTimer.schedule(TimerTask, long, long)
.
-
checkMinIdle
public static <T> TimerTask checkMinIdle(ObjectPool<T> pool, int minIdle, long periodMillis) throws IllegalArgumentException Periodically check the idle object count for the pool. At most one idle object will be added per period. If there is an exception when callingObjectPool.addObject()
then no more checks will be performed.- Type Parameters:
T
- the type of objects in the pool- Parameters:
pool
- the pool to check periodically.minIdle
- if theObjectPool.getNumIdle()
is less than this then add an idle object.periodMillis
- the frequency in milliseconds to check the number of idle objects in a pool, seeTimer.schedule(TimerTask, long, long)
.- Returns:
- the
TimerTask
that will periodically check the pools idle object count. - Throws:
IllegalArgumentException
- whenpool
isnull
or whenminIdle
is negative or whenperiod
isn't valid forTimer.schedule(TimerTask, long, long)
-
checkRethrow
Should the supplied Throwable be re-thrown (eg if it is an instance of one of the Throwables that should never be swallowed). Used by the pool error handling for operations that throw exceptions that normally need to be ignored.- Parameters:
t
- The Throwable to check- Throws:
VirtualMachineError
- if that is passed in
-
erodingPool
Returns a pool that adaptively decreases its size when idle objects are no longer needed. This is intended as an always thread-safe alternative to using an idle object evictor provided by many pool implementations. This is also an effective way to shrink FIFO ordered pools that experience load spikes.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the KeyedObjectPool to be decorated so it shrinks its idle count when possible.- Returns:
- a pool that adaptively decreases its size when idle objects are no longer needed.
- Throws:
IllegalArgumentException
- whenkeyedPool
isnull
.- See Also:
-
erodingPool
Returns a pool that adaptively decreases its size when idle objects are no longer needed. This is intended as an always thread-safe alternative to using an idle object evictor provided by many pool implementations. This is also an effective way to shrink FIFO ordered pools that experience load spikes.The factor parameter provides a mechanism to tweak the rate at which the pool tries to shrink its size. Values between 0 and 1 cause the pool to try to shrink its size more often. Values greater than 1 cause the pool to less frequently try to shrink its size.
- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the KeyedObjectPool to be decorated so it shrinks its idle count when possible.factor
- a positive value to scale the rate at which the pool tries to reduce its size. If 0 < factor < 1 then the pool shrinks more aggressively. If 1 < factor then the pool shrinks less aggressively.- Returns:
- a pool that adaptively decreases its size when idle objects are no longer needed.
- Throws:
IllegalArgumentException
- whenkeyedPool
isnull
or whenfactor
is not positive.- See Also:
-
erodingPool
public static <K,V> KeyedObjectPool<K,V> erodingPool(KeyedObjectPool<K, V> keyedPool, float factor, boolean perKey) Returns a pool that adaptively decreases its size when idle objects are no longer needed. This is intended as an always thread-safe alternative to using an idle object evictor provided by many pool implementations. This is also an effective way to shrink FIFO ordered pools that experience load spikes.The factor parameter provides a mechanism to tweak the rate at which the pool tries to shrink its size. Values between 0 and 1 cause the pool to try to shrink its size more often. Values greater than 1 cause the pool to less frequently try to shrink its size.
The perKey parameter determines if the pool shrinks on a whole pool basis or a per key basis. When perKey is false, the keys do not have an effect on the rate at which the pool tries to shrink its size. When perKey is true, each key is shrunk independently.
- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the KeyedObjectPool to be decorated so it shrinks its idle count when possible.factor
- a positive value to scale the rate at which the pool tries to reduce its size. If 0 < factor < 1 then the pool shrinks more aggressively. If 1 < factor then the pool shrinks less aggressively.perKey
- when true, each key is treated independently.- Returns:
- a pool that adaptively decreases its size when idle objects are no longer needed.
- Throws:
IllegalArgumentException
- whenkeyedPool
isnull
or whenfactor
is not positive.- See Also:
-
erodingPool
Returns a pool that adaptively decreases its size when idle objects are no longer needed. This is intended as an always thread-safe alternative to using an idle object evictor provided by many pool implementations. This is also an effective way to shrink FIFO ordered pools that experience load spikes.- Type Parameters:
T
- the type of objects in the pool- Parameters:
pool
- the ObjectPool to be decorated so it shrinks its idle count when possible.- Returns:
- a pool that adaptively decreases its size when idle objects are no longer needed.
- Throws:
IllegalArgumentException
- whenpool
isnull
.- See Also:
-
erodingPool
Returns a pool that adaptively decreases its size when idle objects are no longer needed. This is intended as an always thread-safe alternative to using an idle object evictor provided by many pool implementations. This is also an effective way to shrink FIFO ordered pools that experience load spikes.The factor parameter provides a mechanism to tweak the rate at which the pool tries to shrink its size. Values between 0 and 1 cause the pool to try to shrink its size more often. Values greater than 1 cause the pool to less frequently try to shrink its size.
- Type Parameters:
T
- the type of objects in the pool- Parameters:
pool
- the ObjectPool to be decorated so it shrinks its idle count when possible.factor
- a positive value to scale the rate at which the pool tries to reduce its size. If 0 < factor < 1 then the pool shrinks more aggressively. If 1 < factor then the pool shrinks less aggressively.- Returns:
- a pool that adaptively decreases its size when idle objects are no longer needed.
- Throws:
IllegalArgumentException
- whenpool
isnull
or whenfactor
is not positive.- See Also:
-
prefill
@Deprecated public static <K,V> void prefill(KeyedObjectPool<K, V> keyedPool, Collection<K> keys, int count) throws Exception, IllegalArgumentExceptionDeprecated.CallsKeyedObjectPool.addObject(Object)
onkeyedPool
with each key inkeys
forcount
number of times. This has the same effect as callingprefill(KeyedObjectPool, Object, int)
for each key in thekeys
collection.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the keyedPool to prefill.keys
-Collection
of keys to add objects for.count
- the number of idle objects to add for eachkey
.- Throws:
Exception
- whenKeyedObjectPool.addObject(Object)
fails.IllegalArgumentException
- whenkeyedPool
,keys
, or any value inkeys
isnull
.- See Also:
-
prefill
@Deprecated public static <K,V> void prefill(KeyedObjectPool<K, V> keyedPool, K key, int count) throws Exception, IllegalArgumentExceptionDeprecated.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the keyedPool to prefill.key
- the key to add objects for.count
- the number of idle objects to add forkey
.- Throws:
Exception
- whenKeyedObjectPool.addObject(Object)
fails.IllegalArgumentException
- whenkeyedPool
orkey
isnull
.
-
prefill
Deprecated.- Type Parameters:
T
- the type of objects in the pool- Parameters:
pool
- the pool to prefill.count
- the number of idle objects to add.- Throws:
Exception
- whenObjectPool.addObject()
fails.IllegalArgumentException
- whenpool
isnull
.
-
synchronizedKeyedPooledFactory
public static <K,V> KeyedPooledObjectFactory<K,V> synchronizedKeyedPooledFactory(KeyedPooledObjectFactory<K, V> keyedFactory) Returns a synchronized (thread-safe) KeyedPooledObjectFactory backed by the specified KeyedPooledObjectFactory.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedFactory
- the KeyedPooledObjectFactory to be "wrapped" in a synchronized KeyedPooledObjectFactory.- Returns:
- a synchronized view of the specified KeyedPooledObjectFactory.
-
synchronizedPool
Returns a synchronized (thread-safe) KeyedObjectPool backed by the specified KeyedObjectPool.Note: This should not be used on pool implementations that already provide proper synchronization such as the pools provided in the Commons Pool library. Wrapping a pool that
waits
for poolable objects to be returned before allowing another one to be borrowed with another layer of synchronization will cause liveliness issues or a deadlock.- Type Parameters:
K
- the type of the pool keyV
- the type of pool entries- Parameters:
keyedPool
- the KeyedObjectPool to be "wrapped" in a synchronized KeyedObjectPool.- Returns:
- a synchronized view of the specified KeyedObjectPool.
-
synchronizedPool
Returns a synchronized (thread-safe) ObjectPool backed by the specified ObjectPool.Note: This should not be used on pool implementations that already provide proper synchronization such as the pools provided in the Commons Pool library. Wrapping a pool that
waits
for poolable objects to be returned before allowing another one to be borrowed with another layer of synchronization will cause liveliness issues or a deadlock.- Type Parameters:
T
- the type of objects in the pool- Parameters:
pool
- the ObjectPool to be "wrapped" in a synchronized ObjectPool.- Returns:
- a synchronized view of the specified ObjectPool.
- Throws:
IllegalArgumentException
- whenpool
isnull
.
-
synchronizedPooledFactory
Returns a synchronized (thread-safe) PooledObjectFactory backed by the specified PooledObjectFactory.- Type Parameters:
T
- the type of objects in the pool- Parameters:
factory
- the PooledObjectFactory to be "wrapped" in a synchronized PooledObjectFactory.- Returns:
- a synchronized view of the specified PooledObjectFactory.
-
KeyedObjectPool.addObjects(Collection, int)
.