T - the type of objects held in this poolpublic interface ObjectPool<T>
 ObjectPool defines a trivially simple pooling interface. The only
 required methods are borrowObject, returnObject
 and invalidateObject.
 
Example of use:
Object obj =null;try{ obj = pool.borrowObject();try{//...use the object...}catch(Exception e) {// invalidate the objectpool.invalidateObject(obj);// do not return the object to the pool twiceobj =null; }finally{// make sure the object is returned to the poolif(null!= obj) { pool.returnObject(obj); } } }catch(Exception e) {// failed to borrow an object}
See BaseObjectPool for a simple base implementation.
PoolableObjectFactory, 
ObjectPoolFactory, 
KeyedObjectPool, 
BaseObjectPool| Modifier and Type | Method and Description | 
|---|---|
| void | addObject()Create an object using the  factoryor other
 implementation dependent mechanism, passivate it, and then place it in the idle object pool. | 
| T | borrowObject()Obtains an instance from this pool. | 
| void | clear()Clears any objects sitting idle in the pool, releasing any
 associated resources (optional operation). | 
| void | close()Close this pool, and free any resources associated with it. | 
| int | getNumActive()Return the number of instances
 currently borrowed from this pool
 (optional operation). | 
| int | getNumIdle()Return the number of instances
 currently idle in this pool (optional operation). | 
| void | invalidateObject(T obj)Invalidates an object from the pool. | 
| void | returnObject(T obj)Return an instance to the pool. | 
| void | setFactory(PoolableObjectFactory<T> factory)Deprecated. 
 to be removed in pool 2.0 | 
T borrowObject() throws Exception, NoSuchElementException, IllegalStateException
 Instances returned from this method will have been either newly created with
 makeObject or will be a previously idle object and
 have been activated with activateObject and
 then validated with validateObject.
 
 By contract, clients must return the borrowed instance using
 returnObject, invalidateObject, or a related method
 as defined in an implementation or sub-interface.
 
 The behaviour of this method when the pool has been exhausted
 is not strictly specified (although it may be specified by implementations).
 Older versions of this method would return null to indicate exhaustion,
 newer versions are encouraged to throw a NoSuchElementException.
 
IllegalStateException - after close has been called on this pool.Exception - when makeObject throws an exception.NoSuchElementException - when the pool is exhausted and cannot or will not return another instance.void returnObject(T obj) throws Exception
obj must have been obtained
 using borrowObject
 or a related method as defined in an implementation
 or sub-interface.void invalidateObject(T obj) throws Exception
Invalidates an object from the pool.
By contract, obj must have been obtained
 using borrowObject or a related method as defined in
 an implementation or sub-interface.
This method should be used when an object that has been borrowed is determined (due to an exception or other problem) to be invalid.
void addObject()
               throws Exception,
                      IllegalStateException,
                      UnsupportedOperationException
factory or other
 implementation dependent mechanism, passivate it, and then place it in the idle object pool.
 addObject is useful for "pre-loading" a pool with idle objects.
 (Optional operation).Exception - when PoolableObjectFactory.makeObject() fails.IllegalStateException - after close() has been called on this pool.UnsupportedOperationException - when this pool cannot add new idle objects.int getNumIdle()
               throws UnsupportedOperationException
borrowed
 without creating any new instances.
 Returns a negative value if this information is not available.UnsupportedOperationException - deprecated: if this implementation does not support the operationint getNumActive()
                 throws UnsupportedOperationException
UnsupportedOperationException - deprecated: if this implementation does not support the operationvoid clear()
           throws Exception,
                  UnsupportedOperationException
destroyed.UnsupportedOperationException - if this implementation does not support the operationExceptionvoid close()
           throws Exception
 Calling addObject() or borrowObject() after invoking
 this method on a pool will cause them to throw an
 IllegalStateException.
 
Exception - deprecated: implementations should silently fail if not all resources can be freed.@Deprecated void setFactory(PoolableObjectFactory<T> factory) throws IllegalStateException, UnsupportedOperationException
factory this pool uses
 to create new instances (optional operation). Trying to change
 the factory after a pool has been used will frequently
 throw an UnsupportedOperationException. It is up to the pool
 implementation to determine when it is acceptable to call this method.factory - the PoolableObjectFactory used to create new instances.IllegalStateException - when the factory cannot be set at this timeUnsupportedOperationException - if this implementation does not support the operationCopyright © 2000-2020 Apache Software Foundation. All Rights Reserved.