org.apache.tomcat.dbcp.pool.impl

## Class SoftReferenceObjectPool<T>

- java.lang.Object
- - org.apache.tomcat.dbcp.pool.BaseObjectPool<T>
  - - org.apache.tomcat.dbcp.pool.impl.SoftReferenceObjectPool<T>

- Type Parameters:
    `T` - the type of objects held in this pool
  All Implemented Interfaces:
    ObjectPool<T>

      public class SoftReferenceObjectPool<T>
      extends BaseObjectPool<T>

  A `SoftReference` based `ObjectPool`.
  Since:
    Pool 1.0
  Author:
    Rodney Waldhoff, Sandy McArthur

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `SoftReferenceObjectPool()` Deprecated. to be removed in pool 2.0. Use `SoftReferenceObjectPool(PoolableObjectFactory)`.
    `SoftReferenceObjectPool(PoolableObjectFactory<T> factory)` Create a `SoftReferenceObjectPool` with the specified factory.
    `SoftReferenceObjectPool(PoolableObjectFactory<T> factory, int initSize)` Deprecated. because this is a SoftReference pool, prefilled idle obejects may be garbage collected before they are used. To be removed in Pool 2.0.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addObject()` Create an object, and place it into the pool.
    `T` | `borrowObject()` Borrow an object from the pool.
    `void` | `clear()` Clears any objects sitting idle in the pool.
    `void` | `close()` Close this pool, and free any resources associated with it.
    `PoolableObjectFactory<T>` | `getFactory()` Returns the `PoolableObjectFactory` used by this pool to create and manage object instances.
    `int` | `getNumActive()` Return the number of instances currently borrowed from this pool.
    `int` | `getNumIdle()` Returns an approximation not less than the of the number of idle instances in the pool.
    `void` | `invalidateObject(T obj)` Invalidates an object from the pool.
    `void` | `returnObject(T obj)` Returns an instance to the pool after successful validation and passivation.
    `void` | `setFactory(PoolableObjectFactory<T> factory)` Deprecated. to be removed in pool 2.0

    - ### Methods inherited from class org.apache.tomcat.dbcp.pool.BaseObjectPool

      `assertOpen, isClosed`

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

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

- - ### Constructor Detail

    - #### SoftReferenceObjectPool

          @Deprecated
          public SoftReferenceObjectPool()

      Deprecated. to be removed in pool 2.0. Use `SoftReferenceObjectPool(PoolableObjectFactory)`.
      Create a `SoftReferenceObjectPool` without a factory. `setFactory` should be called before any attempts to use the pool are made. Generally speaking you should prefer the `SoftReferenceObjectPool(PoolableObjectFactory)` constructor.
      See Also:
        `SoftReferenceObjectPool(PoolableObjectFactory)`

    - #### SoftReferenceObjectPool

          public SoftReferenceObjectPool(PoolableObjectFactory<T> factory)

      Create a `SoftReferenceObjectPool` with the specified factory.
      Parameters:
        `factory` - object factory to use.

    - #### SoftReferenceObjectPool

          @Deprecated
          public SoftReferenceObjectPool(PoolableObjectFactory<T> factory,
                                            int initSize)
                                  throws java.lang.Exception,
                                         java.lang.IllegalArgumentException

      Deprecated. because this is a SoftReference pool, prefilled idle obejects may be garbage collected before they are used. To be removed in Pool 2.0.
      Create a `SoftReferenceObjectPool` with the specified factory and initial idle object count.
      Parameters:
        `factory` - object factory to use.
        `initSize` - initial size to attempt to prefill the pool.
      Throws:
        `java.lang.Exception` - when there is a problem prefilling the pool.
        `java.lang.IllegalArgumentException` - when `factory` is `null`.

  - ### Method Detail

    - #### borrowObject

          public T borrowObject()
                         throws java.lang.Exception

      Borrow an object from the pool. If there are no idle instances available in the pool, the configured factory's `PoolableObjectFactory.makeObject()` method is invoked to create a new instance.

      All instances are `activated` and `validated` before being returned by this method. If validation fails or an exception occurs activating or validating an idle instance, the failing instance is `destroyed` and another instance is retrieved from the pool, validated and activated. This process continues until either the pool is empty or an instance passes validation. If the pool is empty on activation or it does not contain any valid instances, the factory's `makeObject` method is used to create a new instance. If the created instance either raises an exception on activation or fails validation, `NoSuchElementException` is thrown. Exceptions thrown by `MakeObject` are propagated to the caller; but other than `ThreadDeath` or `VirtualMachineError`, exceptions generated by activation, validation or destroy methods are swallowed silently.

      Specified by:
        `borrowObject` in interface `ObjectPool<T>`
      Specified by:
        `borrowObject` in class `BaseObjectPool<T>`
      Returns:
        a valid, activated object instance
      Throws:
        `java.util.NoSuchElementException` - if a valid object cannot be provided
        `java.lang.IllegalStateException` - if invoked on a `closed` pool
        `java.lang.Exception` - if an exception occurs creating a new instance

    - #### returnObject

          public void returnObject(T obj)
                            throws java.lang.Exception

      Returns an instance to the pool after successful validation and passivation. The returning instance is destroyed if any of the following are true:

      - the pool is closed
      - `validation` fails
      - `passivation` throws an exception

      Exceptions passivating or destroying instances are silently swallowed. Exceptions validating instances are propagated to the client.

      Specified by:
        `returnObject` in interface `ObjectPool<T>`
      Specified by:
        `returnObject` in class `BaseObjectPool<T>`
      Parameters:
        `obj` - instance to return to the pool
      Throws:
        `java.lang.Exception`

    - #### invalidateObject

          public void invalidateObject(T obj)
                                throws java.lang.Exception

      Invalidates an object from the pool.

      By contract, `obj` must have been obtained using `borrowObject`.

      This method should be used when an object that has been borrowed is determined (due to an exception or other problem) to be invalid.

      Specified by:
        `invalidateObject` in interface `ObjectPool<T>`
      Specified by:
        `invalidateObject` in class `BaseObjectPool<T>`
      Parameters:
        `obj` - a `borrowed` instance to be disposed.
      Throws:
        `java.lang.Exception`

    - #### addObject

          public void addObject()
                         throws java.lang.Exception

      Create an object, and place it into the pool. addObject() is useful for "pre-loading" a pool with idle objects.

      Before being added to the pool, the newly created instance is `validated` and `passivated`. If validation fails, the new instance is `destroyed`. Exceptions generated by the factory `makeObject` or `passivate` are propagated to the caller. Exceptions destroying instances are silently swallowed.

      Specified by:
        `addObject` in interface `ObjectPool<T>`
      Overrides:
        `addObject` in class `BaseObjectPool<T>`
      Throws:
        `java.lang.IllegalStateException` - if invoked on a `closed` pool
        `java.lang.Exception` - when the `factory` has a problem creating or passivating an object.

    - #### getNumIdle

          public int getNumIdle()

      Returns an approximation not less than the of the number of idle instances in the pool.
      Specified by:
        `getNumIdle` in interface `ObjectPool<T>`
      Overrides:
        `getNumIdle` in class `BaseObjectPool<T>`
      Returns:
        estimated number of idle instances in the pool

    - #### getNumActive

          public int getNumActive()

      Return the number of instances currently borrowed from this pool.
      Specified by:
        `getNumActive` in interface `ObjectPool<T>`
      Overrides:
        `getNumActive` in class `BaseObjectPool<T>`
      Returns:
        the number of instances currently borrowed from this pool

    - #### clear

          public void clear()

      Clears any objects sitting idle in the pool.
      Specified by:
        `clear` in interface `ObjectPool<T>`
      Overrides:
        `clear` in class `BaseObjectPool<T>`

    - #### close

          public void close()
                     throws java.lang.Exception

      Close this pool, and free any resources associated with it. Invokes `clear()` to destroy and remove instances in the pool.

      Calling `addObject()` or `borrowObject()` after invoking this method on a pool will cause them to throw an `IllegalStateException`.

      Specified by:
        `close` in interface `ObjectPool<T>`
      Overrides:
        `close` in class `BaseObjectPool<T>`
      Throws:
        `java.lang.Exception` - never - exceptions clearing the pool are swallowed

    - #### setFactory

          @Deprecated
          public void setFactory(PoolableObjectFactory<T> factory)
                          throws java.lang.IllegalStateException

      Deprecated. to be removed in pool 2.0
      Sets the `factory` this pool uses to create new instances. Trying to change the `factory` while there are borrowed objects will throw an `IllegalStateException`.
      Specified by:
        `setFactory` in interface `ObjectPool<T>`
      Overrides:
        `setFactory` in class `BaseObjectPool<T>`
      Parameters:
        `factory` - the `PoolableObjectFactory` used to create new instances.
      Throws:
        `java.lang.IllegalStateException` - when the factory cannot be set at this time

    - #### getFactory

          public PoolableObjectFactory<T> getFactory()

      Returns the `PoolableObjectFactory` used by this pool to create and manage object instances.
      Returns:
        the factory
      Since:
        1.5.5

Copyright © 2000-2020 Apache Software Foundation. All Rights Reserved.