Package org.apache.tomcat.dbcp.pool2

# Class PoolUtils

java.lang.Object
org.apache.tomcat.dbcp.pool2.PoolUtils

public final class PoolUtils extends Object
This class consists exclusively of static methods that operate on or return ObjectPool or KeyedObjectPool related interfaces.

Since:
  2.0

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `MSG_NULL_KEY`
  `static final String`
  `MSG_NULL_KEYS`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `PoolUtils()`
  PoolUtils instances should NOT be constructed in standard programming.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static <K, V> Map<K,TimerTask>`
  `checkMinIdle(KeyedObjectPool<K,V> keyedPool, Collection<K> keys, int minIdle, long period)`
  Periodically check the idle object count for each key in the `Collection keys` in the keyedPool.
  `static <K, V> TimerTask`
  `checkMinIdle(KeyedObjectPool<K,V> keyedPool, K key, int minIdle, long period)`
  Periodically check the idle object count for the key in the keyedPool.
  `static <T> TimerTask`
  `checkMinIdle(ObjectPool<T> pool, int minIdle, long period)`
  Periodically check the idle object count for the pool.
  `static void`
  `checkRethrow(Throwable t)`
  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> void`
  `prefill(KeyedObjectPool<K,V> keyedPool, Collection<K> keys, int count)`
  Deprecated.
  Use `KeyedObjectPool.addObjects(Collection, int)`.
  `static <K, V> void`
  `prefill(KeyedObjectPool<K,V> keyedPool, K key, int count)`
  Deprecated.
  Use `KeyedObjectPool.addObjects(Object, int)`.
  `static <T> void`
  `prefill(ObjectPool<T> pool, int count)`
  Deprecated.
  Use `ObjectPool.addObjects(int)`.
  `static <K, V> KeyedPooledObjectFactory<K,V>`
  `synchronizedKeyedPooledFactory(KeyedPooledObjectFactory<K,V> keyedFactory)`
  Returns a synchronized (thread-safe) KeyedPooledObjectFactory backed by the specified KeyedPoolableObjectFactory.
  `static <T> PooledObjectFactory<T>`
  `synchronizedPooledFactory(PooledObjectFactory<T> factory)`
  Returns a synchronized (thread-safe) PooledObjectFactory backed by the specified PooledObjectFactory.

  ### Methods inherited from class java.lang.Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### MSG_NULL_KEY

    public static final String MSG_NULL_KEY
    See Also:
      - Constant Field Values

  - ### MSG_NULL_KEYS

    public static final String MSG_NULL_KEYS
    See Also:
      - Constant Field Values

- ## 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

  - ### checkRethrow

    public static void checkRethrow(Throwable t)
    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:
      `ThreadDeath` - if that is passed in
      `VirtualMachineError` - if that is passed in

  - ### checkMinIdle

    public static <T> TimerTask checkMinIdle(ObjectPool<T> pool, int minIdle, long period) 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 calling `ObjectPool.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 the `ObjectPool.getNumIdle()` is less than this then add an idle object.
      `period` - the frequency to check the number of idle objects in a pool, see `Timer.schedule(TimerTask, long, long)`.
    Returns:
      the `TimerTask` that will periodically check the pools idle object count.
    Throws:
      `IllegalArgumentException` - when `pool` is `null` or when `minIdle` is negative or when `period` isn't valid for `Timer.schedule(TimerTask, long, long)`

  - ### checkMinIdle

    public static <K, V> TimerTask checkMinIdle(KeyedObjectPool<K,V> keyedPool, K key, int minIdle, long period) throws IllegalArgumentException
    Periodically 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 calling `KeyedObjectPool.addObject(Object)` then no more checks for that key will be performed.
    Type Parameters:
      `K` - the type of the pool key
      `V` - the type of pool entries
    Parameters:
      `keyedPool` - the keyedPool to check periodically.
      `key` - the key to check the idle count of.
      `minIdle` - if the `KeyedObjectPool.getNumIdle(Object)` is less than this then add an idle object.
      `period` - the frequency to check the number of idle objects in a keyedPool, see `Timer.schedule(TimerTask, long, long)`.
    Returns:
      the `TimerTask` that will periodically check the pools idle object count.
    Throws:
      `IllegalArgumentException` - when `keyedPool`, `key` is `null` or when `minIdle` is negative or when `period` isn't valid for `Timer.schedule(TimerTask, long, long)`.

  - ### checkMinIdle

    public static <K, V> Map<K,TimerTask> checkMinIdle(KeyedObjectPool<K,V> keyedPool, Collection<K> keys, int minIdle, long period) throws IllegalArgumentException
    Periodically check the idle object count for each key in the `Collection keys` in the keyedPool. At most one idle object will be added per period.
    Type Parameters:
      `K` - the type of the pool key
      `V` - 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 the `KeyedObjectPool.getNumIdle(Object)` is less than this then add an idle object.
      `period` - the frequency to check the number of idle objects in a keyedPool, see `Timer.schedule(TimerTask, long, long)`.
    Returns:
      a `Map` of key and `TimerTask` pairs that will periodically check the pools idle object count.
    Throws:
      `IllegalArgumentException` - when `keyedPool`, `keys`, or any of the values in the collection is `null` or when `minIdle` is negative or when `period` isn't valid for `Timer.schedule(TimerTask, long, long)`.
    See Also:
      - `checkMinIdle(KeyedObjectPool, Object, int, long)`

  - ### prefill

    @Deprecated public static <T> void prefill(ObjectPool<T> pool, int count) throws Exception, IllegalArgumentException
    Deprecated.
    Use `ObjectPool.addObjects(int)`.
    Calls `ObjectPool.addObject()` on `pool` `count` number of times.
    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` - when `ObjectPool.addObject()` fails.
      `IllegalArgumentException` - when `pool` is `null`.

  - ### prefill

    @Deprecated public static <K, V> void prefill(KeyedObjectPool<K,V> keyedPool, K key, int count) throws Exception, IllegalArgumentException
    Deprecated.
    Use `KeyedObjectPool.addObjects(Object, int)`.
    Calls `KeyedObjectPool.addObject(Object)` on `keyedPool` with `key` `count` number of times.
    Type Parameters:
      `K` - the type of the pool key
      `V` - 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 for `key`.
    Throws:
      `Exception` - when `KeyedObjectPool.addObject(Object)` fails.
      `IllegalArgumentException` - when `keyedPool` or `key` is `null`.

  - ### prefill

    @Deprecated public static <K, V> void prefill(KeyedObjectPool<K,V> keyedPool, Collection<K> keys, int count) throws Exception, IllegalArgumentException
    Deprecated.
    Use `KeyedObjectPool.addObjects(Collection, int)`.
    Calls `KeyedObjectPool.addObject(Object)` on `keyedPool` with each key in `keys` for `count` number of times. This has the same effect as calling `prefill(KeyedObjectPool, Object, int)` for each key in the `keys` collection.
    Type Parameters:
      `K` - the type of the pool key
      `V` - 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 each `key`.
    Throws:
      `Exception` - when `KeyedObjectPool.addObject(Object)` fails.
      `IllegalArgumentException` - when `keyedPool`, `keys`, or any value in `keys` is `null`.
    See Also:
      - `prefill(KeyedObjectPool, Object, int)`

  - ### synchronizedPooledFactory

    public static <T> PooledObjectFactory<T> synchronizedPooledFactory(PooledObjectFactory<T> factory)
    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.

  - ### synchronizedKeyedPooledFactory

    public static <K, V> KeyedPooledObjectFactory<K,V> synchronizedKeyedPooledFactory(KeyedPooledObjectFactory<K,V> keyedFactory)
    Returns a synchronized (thread-safe) KeyedPooledObjectFactory backed by the specified KeyedPoolableObjectFactory.
    Type Parameters:
      `K` - the type of the pool key
      `V` - the type of pool entries
    Parameters:
      `keyedFactory` - the KeyedPooledObjectFactory to be "wrapped" in a synchronized KeyedPooledObjectFactory.
    Returns:
      a synchronized view of the specified KeyedPooledObjectFactory.