| 
 | ||||||
| PREV NEXT | FRAMES NO FRAMES | |||||
See:
          Description
| Packages | |
|---|---|
| org.apache.commons.pool | Object pooling API. | 
| org.apache.commons.pool.impl | Object pooling API implementations. | 
Generic Object pooling API with several implementations.
         The org.apache.commons.pool package defines a simple
         interface for a pool of object instances, and a handful of base
         classes that may be useful when creating pool implementations.
         The API supports pooling of unique objects which can be requested
         via a key as well as pools where all objects are equivalent.
      
         The org.apache.commons.pool.impl package contains
         several pool implementations.
         StackObjectPool
         is useful for supporting reuse of a limited number of instances while
         allowing new instances to be created as needed to support high demand.
         GenericObjectPool has many configuration options and can support
         a limited set of objects such as would be useful in a database
         connection pool.
         SoftReferenceObjectPool has no limit on the number of objects in the
         pool, but the garbage collector can remove idle objects from the pool
         as needed.  There are also keyed versions of the first two.
      
         Here is a simple example of pooling HashMap's. First
         create an ObjectPoolFactory
      
    public class HashMapFactory
        extends BasePoolableObjectFactory
    {
        /**
         * Creates an instance that can be returned by the pool.
         * @return an instance that can be returned by the pool.
         */
        public Object makeObject()
            throws Exception
        {
            return new HashMap();
        }
        /**
         * Uninitialize an instance to be returned to the pool.
         * @param obj the instance to be passivated
         */
        public void passivateObject(Object obj)
            throws Exception
        {
            Map map = (Map)obj;
            map.clear();
        }
    }
      A class that makes frequent use of a Map could then use a pool as shown below:
    public class Foo
    {
        private ObjectPool pool;
        public Foo()
        {
            PoolableObjectFactory factory = new HashMapFactory();
            pool = new StackObjectPool(factory, 1000);
        }
        public doSomething()
        {
            ...
            Map map = null;
            try
            {
                map = (Map)pool.borrowObject();
                // use map
                ...
            }
            finally
            {
                if (map != null)
                {
                    pool.returnObject(map);
                }
            }
            ...
        }
    }
The above example shows how one would use an
ObjectPool.  The other supplied
implementations or another special purpose pool would be used similarly.
| 
 | ||||||
| PREV NEXT | FRAMES NO FRAMES | |||||