SynchronizedKeyedObjectPool(KeyedObjectPool keyedPool) throws IllegalArgumentException 
{
            if (keyedPool == null) {
                throw new IllegalArgumentException("keyedPool must not be null.");
            }
            this.keyedPool = keyedPool;
            lock = new Object();
}

 public  void addObject(Object key) throws Exception, UnsupportedOperationException, IllegalStateException 
{
            synchronized (lock) {
                keyedPool.addObject(key);
            }
}

 public Object borrowObject(Object key) throws Exception, NoSuchElementException, IllegalStateException 
{
            synchronized (lock) {
                return keyedPool.borrowObject(key);
            }
}

 public  void clear() throws Exception, UnsupportedOperationException 
{
            synchronized (lock) {
                keyedPool.clear();
            }
}

 public  void clear(Object key) throws Exception, UnsupportedOperationException 
{
            synchronized (lock) {
                keyedPool.clear(key);
            }
}

 public  void close() 
{
            try {
                synchronized (lock) {
                    keyedPool.close();
                }
            } catch (Exception e) {
                // swallowed as of Pool 2
            }
}

 public int getNumActive() throws UnsupportedOperationException 
{
            synchronized (lock) {
                return keyedPool.getNumActive();
            }
}

 public int getNumActive(Object key) throws UnsupportedOperationException 
{
            synchronized (lock) {
                return keyedPool.getNumActive(key);
            }
}

 public int getNumIdle() throws UnsupportedOperationException 
{
            synchronized (lock) {
                return keyedPool.getNumIdle();
            }
}

 public int getNumIdle(Object key) throws UnsupportedOperationException 
{
            synchronized (lock) {
                return keyedPool.getNumIdle(key);
            }
}

 public  void invalidateObject(Object key,
    Object obj) 
{
            synchronized (lock) {
                try {
                    keyedPool.invalidateObject(key, obj);
                } catch (Exception e) {
                    // swallowed as of Pool 2
                }
            }
}

 public  void returnObject(Object key,
    Object obj) 
{
            synchronized (lock) {
                try {
                    keyedPool.returnObject(key, obj);
                } catch (Exception e) {
                    // swallowed
                }
            }
}

 public  void setFactory(KeyedPoolableObjectFactory factory) throws UnsupportedOperationException, IllegalStateException 
{
            synchronized (lock) {
                keyedPool.setFactory(factory);
            }
}

 public String toString() 
{
            final StringBuffer sb = new StringBuffer();
            sb.append("SynchronizedKeyedObjectPool");
            sb.append("{keyedPool=").append(keyedPool);
            sb.append('}");
            return sb.toString();
}