/** * <p>Close this pool, and free any resources associated with it. Invokes * {@link #clear()} to destroy and remove instances in the pool.</p> * * <p>Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}.</p> * * @throws Exception never - exceptions clearing the pool are swallowed */ @Override public void close() throws Exception { super.close(); clear(); }
/** * <p>Close this pool, and free any resources associated with it. Invokes * {@link #clear()} to destroy and remove instances in the pool.</p> * * <p>Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}.</p> * * @throws Exception never - exceptions clearing the pool are swallowed */ @Override public void close() throws Exception { super.close(); clear(); }
/** * <p>Closes the pool. Once the pool is closed, {@link #borrowObject()} * will fail with IllegalStateException, but {@link #returnObject(Object)} and * {@link #invalidateObject(Object)} will continue to work, with returned objects * destroyed on return.</p> * * <p>Destroys idle instances in the pool by invoking {@link #clear()}.</p> * * @throws Exception */ @Override public void close() throws Exception { super.close(); synchronized (this) { clear(); startEvictor(-1L); while(_allocationQueue.size() > 0) { Latch<T> l = _allocationQueue.removeFirst(); synchronized (l) { // notify the waiting thread l.notify(); } } } }
public void close() throws Exception { super.close(); clear(); }
public void close() throws Exception { super.close(); clear(); }
/** * Close this pool, and free any resources associated with it. * <p> * Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}. * </p> * * @throws Exception <strong>deprecated</strong>: implementations should silently fail if not all resources can be freed. */ public void close() throws Exception { super.close(); clear(); }
/** * <p>Close this pool, and free any resources associated with it. Invokes * {@link #clear()} to destroy and remove instances in the pool.</p> * * <p>Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}.</p> * * @throws Exception never - exceptions clearing the pool are swallowed */ @Override public void close() throws Exception { super.close(); clear(); }
/** * Close this pool, and free any resources associated with it. * <p> * Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}. * </p> * * @throws Exception <strong>deprecated</strong>: implementations should silently fail if not all resources can be freed. */ public void close() throws Exception { super.close(); clear(); }
/** * <p>Close this pool, and free any resources associated with it. Invokes * {@link #clear()} to destroy and remove instances in the pool.</p> * * <p>Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}.</p> * * @throws Exception never - exceptions clearing the pool are swallowed */ @Override public void close() throws Exception { super.close(); clear(); }
/** * <p>Close this pool, and free any resources associated with it. Invokes * {@link #clear()} to destroy and remove instances in the pool.</p> * * <p>Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}.</p> * * @throws Exception never - exceptions clearing the pool are swallowed */ @Override public void close() throws Exception { super.close(); clear(); }
/** * <p>Close this pool, and free any resources associated with it. Invokes * {@link #clear()} to destroy and remove instances in the pool.</p> * * <p>Calling {@link #addObject} or {@link #borrowObject} after invoking * this method on a pool will cause them to throw an * {@link IllegalStateException}.</p> * * @throws Exception never - exceptions clearing the pool are swallowed */ @Override public void close() throws Exception { super.close(); clear(); }
/** * <p>Closes the pool. Once the pool is closed, {@link #borrowObject()} * will fail with IllegalStateException, but {@link #returnObject(Object)} and * {@link #invalidateObject(Object)} will continue to work, with returned objects * destroyed on return.</p> * * <p>Destroys idle instances in the pool by invoking {@link #clear()}.</p> * * @throws Exception */ @Override public void close() throws Exception { super.close(); synchronized (this) { clear(); startEvictor(-1L); while(_allocationQueue.size() > 0) { Latch<T> l = _allocationQueue.removeFirst(); synchronized (l) { // notify the waiting thread l.notify(); } } } }
/** * <p>Closes the pool. Once the pool is closed, {@link #borrowObject()} * will fail with IllegalStateException, but {@link #returnObject(Object)} and * {@link #invalidateObject(Object)} will continue to work, with returned objects * destroyed on return.</p> * * <p>Destroys idle instances in the pool by invoking {@link #clear()}.</p> * * @throws Exception */ @Override public void close() throws Exception { super.close(); synchronized (this) { clear(); startEvictor(-1L); while(_allocationQueue.size() > 0) { Latch<T> l = _allocationQueue.removeFirst(); synchronized (l) { // notify the waiting thread l.notify(); } } } }
/** * Closes the pool. Once the pool is closed, {@link #borrowObject()} * will fail with IllegalStateException, but {@link #returnObject(Object)} and * {@link #invalidateObject(Object)} will continue to work. This method does not * {@link #clear()} the pool. The method is idempotent - that is, it is OK to call it on a closed * pool. * * @throws Exception */ public void close() throws Exception { super.close(); synchronized (this) { clear(); startEvictor(-1L); } }
/** * Closes the pool. Once the pool is closed, {@link #borrowObject()} * will fail with IllegalStateException, but {@link #returnObject(Object)} and * {@link #invalidateObject(Object)} will continue to work. This method does not * {@link #clear()} the pool. The method is idempotent - that is, it is OK to call it on a closed * pool. * * @throws Exception */ public void close() throws Exception { super.close(); synchronized (this) { clear(); startEvictor(-1L); } }