public SoftReferenceObjectPool() 
{
        _pool = new ArrayList();
        _factory = null;
}

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.

Also see:

SoftReferenceObjectPool(PoolableObjectFactory)

 public SoftReferenceObjectPool(PoolableObjectFactory factory) 
{
        _pool = new ArrayList();
        _factory = factory;
}

Create a SoftReferenceObjectPool with the specified factory.

Parameters:

factory - object factory to use.

 public SoftReferenceObjectPool(PoolableObjectFactory factory,
    int initSize) throws Exception, IllegalArgumentException 
{
        if (factory == null) {
            throw new IllegalArgumentException("factory required to prefill the pool.");
        }
        _pool = new ArrayList(initSize);
        _factory = factory;
        PoolUtils.prefill(this, initSize);
}

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:

Exception - when there is a problem prefilling the pool.

IllegalArgumentException - when factory is null.

 public synchronized  void addObject() throws Exception 
{
        assertOpen();
        if (_factory == null) {
            throw new IllegalStateException("Cannot add objects without a factory.");
        }
        Object obj = _factory.makeObject();
        boolean success = true;
        if(!_factory.validateObject(obj)) {
            success = false;
        } else {
            _factory.passivateObject(obj);
        }
        boolean shouldDestroy = !success;
        if(success) {
            _pool.add(new SoftReference(obj, refQueue));
            notifyAll(); // _numActive has changed
        }
        if(shouldDestroy) {
            try {
                _factory.destroyObject(obj);
            } catch(Exception e) {
                // ignored
            }
        }
}

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

 public synchronized Object borrowObject() throws Exception 
{
        assertOpen();
        Object obj = null;
        boolean newlyCreated = false;
        while(null == obj) {
            if(_pool.isEmpty()) {
                if(null == _factory) {
                    throw new NoSuchElementException();
                } else {
                    newlyCreated = true;
                    obj = _factory.makeObject();
                }
            } else {
                SoftReference ref = (SoftReference)(_pool.remove(_pool.size() - 1));
                obj = ref.get();
                ref.clear(); // prevent this ref from being enqueued with refQueue.
            }
            if (null != _factory && null != obj) {
                try {
                    _factory.activateObject(obj);
                    if (!_factory.validateObject(obj)) {
                        throw new Exception("ValidateObject failed");
                    }
                } catch (Throwable t) {
                    try {
                        _factory.destroyObject(obj);
                    } catch (Throwable t2) {
                        // swallowed
                    } finally {
                        obj = null;
                    }
                    if (newlyCreated) {
                        throw new NoSuchElementException(
                            "Could not create a validated object, cause: " +
                            t.getMessage());
                    }
                }
            }
        }
        _numActive++;
        return obj;
}

 public synchronized  void clear() 
{
        if(null != _factory) {
            Iterator iter = _pool.iterator();
            while(iter.hasNext()) {
                try {
                    Object obj = ((SoftReference)iter.next()).get();
                    if(null != obj) {
                        _factory.destroyObject(obj);
                    }
                } catch(Exception e) {
                    // ignore error, keep destroying the rest
                }
            }
        }
        _pool.clear();
        pruneClearedReferences();
}

Clears any objects sitting idle in the pool.

 public  void close() throws Exception 
{
        super.close();
        clear();
}

 public synchronized int getNumActive() 
{
        return _numActive;
}

Return the number of instances currently borrowed from this pool.

 public synchronized int getNumIdle() 
{
        pruneClearedReferences();
        return _pool.size();
}

Returns an approximation not less than the of the number of idle instances in the pool.

 public synchronized  void invalidateObject(Object obj) throws Exception 
{
        _numActive--;
        if (_factory != null) {
            _factory.destroyObject(obj);
        }
        notifyAll(); // _numActive has changed
}

 public synchronized  void returnObject(Object obj) throws Exception 
{
        boolean success = !isClosed();
        if (_factory != null) {
            if(!_factory.validateObject(obj)) {
                success = false;
            } else {
                try {
                    _factory.passivateObject(obj);
                } catch(Exception e) {
                    success = false;
                }
            }
        }
        boolean shouldDestroy = !success;
        _numActive--;
        if(success) {
            _pool.add(new SoftReference(obj, refQueue));
        }
        notifyAll(); // _numActive has changed
        if (shouldDestroy && _factory != null) {
            try {
                _factory.destroyObject(obj);
            } catch(Exception e) {
                // ignored
            }
        }
}

 public synchronized  void setFactory(PoolableObjectFactory factory) throws IllegalStateException 
{
        assertOpen();
        if(0 <  getNumActive()) {
            throw new IllegalStateException("Objects are already active");
        } else {
            clear();
            _factory = factory;
        }
}

Sets the factory this pool uses to create new instances. Trying to change the factory while there are borrowed objects will throw an IllegalStateException .