private static class PoolUtils.SynchronizedObjectPool<T> extends java.lang.Object implements ObjectPool<T>
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.
| Modifier and Type | Field and Description |
|---|---|
private ObjectPool<T> |
pool
the underlying object pool
|
private java.util.concurrent.locks.ReentrantReadWriteLock |
readWriteLock
Object whose monitor is used to synchronize methods on the wrapped
pool.
|
| Constructor and Description |
|---|
SynchronizedObjectPool(ObjectPool<T> pool)
Create a new SynchronizedObjectPool wrapping the given pool.
|
| Modifier and Type | Method and Description |
|---|---|
void |
addObject()
Create an object using the
factory or 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.
|
int |
getNumIdle()
Return the number of instances currently idle in this pool.
|
void |
invalidateObject(T obj)
Invalidates an object from the pool.
|
void |
returnObject(T obj)
Return an instance to the pool.
|
java.lang.String |
toString() |
private final java.util.concurrent.locks.ReentrantReadWriteLock readWriteLock
private final ObjectPool<T> pool
SynchronizedObjectPool(ObjectPool<T> pool) throws java.lang.IllegalArgumentException
pool - the ObjectPool to be "wrapped" in a synchronized
ObjectPool.java.lang.IllegalArgumentException - if the pool is nullpublic T borrowObject() throws java.lang.Exception, java.util.NoSuchElementException, java.lang.IllegalStateException
Instances returned from this method will have been either newly created
with PooledObjectFactory.makeObject() or will be a previously
idle object and have been activated with
PooledObjectFactory.activateObject(org.apache.commons.pool2.PooledObject<T>) and then validated with
PooledObjectFactory.validateObject(org.apache.commons.pool2.PooledObject<T>).
By contract, clients must return the borrowed instance
using ObjectPool.returnObject(T), ObjectPool.invalidateObject(T), 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).
borrowObject in interface ObjectPool<T>java.lang.IllegalStateException - after close has been called on this pool.java.lang.Exception - when PooledObjectFactory.makeObject() throws an
exception.java.util.NoSuchElementException - when the pool is exhausted and cannot or will not return
another instance.public void returnObject(T obj)
obj
must have been obtained using ObjectPool.borrowObject() or
a related method as defined in an implementation or sub-interface.returnObject in interface ObjectPool<T>obj - a borrowed instance to be returned.public void invalidateObject(T obj)
By contract, obj must have been obtained
using ObjectPool.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.
invalidateObject in interface ObjectPool<T>obj - a borrowed instance to be disposed.public void addObject()
throws java.lang.Exception,
java.lang.IllegalStateException,
java.lang.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).addObject in interface ObjectPool<T>java.lang.Exception - when PooledObjectFactory.makeObject() fails.java.lang.IllegalStateException - after ObjectPool.close() has been called on this pool.java.lang.UnsupportedOperationException - when this pool cannot add new idle objects.public int getNumIdle()
borrowed without creating any new instances.
Returns a negative value if this information is not available.getNumIdle in interface ObjectPool<T>public int getNumActive()
getNumActive in interface ObjectPool<T>public void clear()
throws java.lang.Exception,
java.lang.UnsupportedOperationException
PooledObjectFactory.destroyObject(PooledObject).clear in interface ObjectPool<T>java.lang.UnsupportedOperationException - if this implementation does not support the operationjava.lang.Exception - if the pool cannot be clearedpublic void close()
Calling ObjectPool.addObject() or ObjectPool.borrowObject() after invoking this
method on a pool will cause them to throw an IllegalStateException.
Implementations should silently fail if not all resources can be freed.
close in interface ObjectPool<T>public java.lang.String toString()
toString in class java.lang.Object