Coverage Report

Coverage Report - org.apache.commons.pool.impl.SoftReferenceObjectPool

Classes in this File

Line Coverage

Branch Coverage

Complexity

SoftReferenceObjectPool

0/113

0/52

3.769

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.commons.pool.impl;
 
 import java.lang.ref.SoftReference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.Reference;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.NoSuchElementException;
 
 import org.apache.commons.pool.BaseObjectPool;
 import org.apache.commons.pool.ObjectPool;
 import org.apache.commons.pool.PoolableObjectFactory;
 import org.apache.commons.pool.PoolUtils;
 
 /**
  * A {@link java.lang.ref.SoftReference SoftReference} based
  * {@link ObjectPool}.
  *
  * @author Rodney Waldhoff
  * @author Sandy McArthur
  * @version $Revision: 777748 $ $Date: 2009-05-22 20:00:44 -0400 (Fri, 22 May 2009) $
  * @since Pool 1.0
  */
 public class SoftReferenceObjectPool extends BaseObjectPool implements ObjectPool {
     /**
      * Create a <code>SoftReferenceObjectPool</code> without a factory.
      * {@link #setFactory(PoolableObjectFactory) setFactory} should be called
      * before any attempts to use the pool are made.
      * Generally speaking you should prefer the {@link #SoftReferenceObjectPool(PoolableObjectFactory)} constructor.
      *
      * @see #SoftReferenceObjectPool(PoolableObjectFactory)
      */
     public SoftReferenceObjectPool() {
         _pool = new ArrayList();
         _factory = null;
     }
 
     /**
      * Create a <code>SoftReferenceObjectPool</code> with the specified factory.
      *
      * @param factory object factory to use.
      */
     public SoftReferenceObjectPool(PoolableObjectFactory factory) {
         _pool = new ArrayList();
         _factory = factory;
     }
 
     /**
      * Create a <code>SoftReferenceObjectPool</code> with the specified factory and initial idle object count.
      *
      * @param factory object factory to use.
      * @param initSize initial size to attempt to prefill the pool.
      * @throws Exception when there is a problem prefilling the pool.
      * @throws IllegalArgumentException when <code>factory</code> is <code>null</code>.
      * @deprecated because this is a SoftReference pool, prefilled idle obejects may be garbage collected before they are used.
      *      To be removed in Pool 3.0.
      */
     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);
     }
 
     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 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 invalidateObject(Object obj) throws Exception {
         _numActive--;
         if (_factory != null) {
             _factory.destroyObject(obj);
         }
         notifyAll(); // _numActive has changed
     }
 
     /**
      * Create an object, and place it into the pool.
      * addObject() is useful for "pre-loading" a pool with idle objects.
      */
     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
             }
         }
     }
 
     /** Returns an approximation not less than the of the number of idle instances in the pool. */
     public synchronized int getNumIdle() {
         pruneClearedReferences();
         return _pool.size();
     }
 
     /**
      * Return the number of instances currently borrowed from this pool.
      *
      * @return the number of instances currently borrowed from this pool
      */
     public synchronized int getNumActive() {
         return _numActive;
     }
 
     /**
      * Clears any objects sitting idle in the pool.
      */
     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();
     }
 
     public void close() throws Exception {
         super.close();
         clear();
     }
 
     /**
      * Sets the {@link PoolableObjectFactory factory} this pool uses
      * to create new instances. Trying to change
      * the <code>factory</code> while there are borrowed objects will
      * throw an {@link IllegalStateException}.
      *
      * @param factory the {@link PoolableObjectFactory} used to create new instances.
      * @throws IllegalStateException when the factory cannot be set at this time
      */
     public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException {
         assertOpen();
         if(0 < getNumActive()) {
             throw new IllegalStateException("Objects are already active");
         } else {
             clear();
             _factory = factory;
         }
     }
 
     /**
      * If any idle objects were garbage collected, remove their
      * {@link Reference} wrappers from the idle object pool.
      */
     private void pruneClearedReferences() {
         Reference ref;
         while ((ref = refQueue.poll()) != null) {
             try {
                 _pool.remove(ref);
             } catch (UnsupportedOperationException uoe) {
                 // ignored
             }
         }
     }
 
     /** My pool. */
     private List _pool = null;
 
     /** My {@link PoolableObjectFactory}. */
     private PoolableObjectFactory _factory = null;
 
     /**
      * Queue of broken references that might be able to be removed from <code>_pool</code>.
      * This is used to help {@link #getNumIdle()} be more accurate with minimial
      * performance overhead.
      */
     private final ReferenceQueue refQueue = new ReferenceQueue();
 
     /** Number of active objects. */
     private int _numActive = 0;
 }

1		/*
2		* Licensed to the Apache Software Foundation (ASF) under one or more
3		* contributor license agreements. See the NOTICE file distributed with
4		* this work for additional information regarding copyright ownership.
5		* The ASF licenses this file to You under the Apache License, Version 2.0
6		* (the "License"); you may not use this file except in compliance with
7		* the License. You may obtain a copy of the License at
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17
18		package org.apache.commons.pool.impl;
19
20		import java.lang.ref.SoftReference;
21		import java.lang.ref.ReferenceQueue;
22		import java.lang.ref.Reference;
23		import java.util.ArrayList;
24		import java.util.Iterator;
25		import java.util.List;
26		import java.util.NoSuchElementException;
27
28		import org.apache.commons.pool.BaseObjectPool;
29		import org.apache.commons.pool.ObjectPool;
30		import org.apache.commons.pool.PoolableObjectFactory;
31		import org.apache.commons.pool.PoolUtils;
32
33		/**
34		* A {@link java.lang.ref.SoftReference SoftReference} based
35		* {@link ObjectPool}.
36		*
37		* @author Rodney Waldhoff
38		* @author Sandy McArthur
39		* @version $Revision: 777748 $ $Date: 2009-05-22 20:00:44 -0400 (Fri, 22 May 2009) $
40		* @since Pool 1.0
41		*/
42		public class SoftReferenceObjectPool extends BaseObjectPool implements ObjectPool {
43		/**
44		* Create a <code>SoftReferenceObjectPool</code> without a factory.
45		* {@link #setFactory(PoolableObjectFactory) setFactory} should be called
46		* before any attempts to use the pool are made.
47		* Generally speaking you should prefer the {@link #SoftReferenceObjectPool(PoolableObjectFactory)} constructor.
48		*
49		* @see #SoftReferenceObjectPool(PoolableObjectFactory)
50		*/
51	0	public SoftReferenceObjectPool() {
52	0	_pool = new ArrayList();
53	0	_factory = null;
54	0	}
55
56		/**
57		* Create a <code>SoftReferenceObjectPool</code> with the specified factory.
58		*
59		* @param factory object factory to use.
60		*/
61	0	public SoftReferenceObjectPool(PoolableObjectFactory factory) {
62	0	_pool = new ArrayList();
63	0	_factory = factory;
64	0	}
65
66		/**
67		* Create a <code>SoftReferenceObjectPool</code> with the specified factory and initial idle object count.
68		*
69		* @param factory object factory to use.
70		* @param initSize initial size to attempt to prefill the pool.
71		* @throws Exception when there is a problem prefilling the pool.
72		* @throws IllegalArgumentException when <code>factory</code> is <code>null</code>.
73		* @deprecated because this is a SoftReference pool, prefilled idle obejects may be garbage collected before they are used.
74		* To be removed in Pool 3.0.
75		*/
76	0	public SoftReferenceObjectPool(PoolableObjectFactory factory, int initSize) throws Exception, IllegalArgumentException {
77	0	if (factory == null) {
78	0	throw new IllegalArgumentException("factory required to prefill the pool.");
79		}
80	0	_pool = new ArrayList(initSize);
81	0	_factory = factory;
82	0	PoolUtils.prefill(this, initSize);
83	0	}
84
85		public synchronized Object borrowObject() throws Exception {
86	0	assertOpen();
87	0	Object obj = null;
88	0	boolean newlyCreated = false;
89	0	while(null == obj) {
90	0	if(_pool.isEmpty()) {
91	0	if(null == _factory) {
92	0	throw new NoSuchElementException();
93		} else {
94	0	newlyCreated = true;
95	0	obj = _factory.makeObject();
96		}
97		} else {
98	0	SoftReference ref = (SoftReference)(_pool.remove(_pool.size() - 1));
99	0	obj = ref.get();
100	0	ref.clear(); // prevent this ref from being enqueued with refQueue.
101		}
102	0	if (null != _factory && null != obj) {
103		try {
104	0	_factory.activateObject(obj);
105	0	if (!_factory.validateObject(obj)) {
106	0	throw new Exception("ValidateObject failed");
107		}
108	0	} catch (Throwable t) {
109		try {
110	0	_factory.destroyObject(obj);
111	0	} catch (Throwable t2) {
112		// swallowed
113		} finally {
114	0	obj = null;
115	0	}
116	0	if (newlyCreated) {
117	0	throw new NoSuchElementException(
118		"Could not create a validated object, cause: " +
119		t.getMessage());
120		}
121	0	}
122		}
123		}
124	0	_numActive++;
125	0	return obj;
126		}
127
128		public synchronized void returnObject(Object obj) throws Exception {
129	0	boolean success = !isClosed();
130	0	if (_factory != null) {
131	0	if(!_factory.validateObject(obj)) {
132	0	success = false;
133		} else {
134		try {
135	0	_factory.passivateObject(obj);
136	0	} catch(Exception e) {
137	0	success = false;
138	0	}
139		}
140		}
141
142	0	boolean shouldDestroy = !success;
143	0	_numActive--;
144	0	if(success) {
145	0	_pool.add(new SoftReference(obj, refQueue));
146		}
147	0	notifyAll(); // _numActive has changed
148
149	0	if (shouldDestroy && _factory != null) {
150		try {
151	0	_factory.destroyObject(obj);
152	0	} catch(Exception e) {
153		// ignored
154	0	}
155		}
156	0	}
157
158		public synchronized void invalidateObject(Object obj) throws Exception {
159	0	_numActive--;
160	0	if (_factory != null) {
161	0	_factory.destroyObject(obj);
162		}
163	0	notifyAll(); // _numActive has changed
164	0	}
165
166		/**
167		* Create an object, and place it into the pool.
168		* addObject() is useful for "pre-loading" a pool with idle objects.
169		*/
170		public synchronized void addObject() throws Exception {
171	0	assertOpen();
172	0	if (_factory == null) {
173	0	throw new IllegalStateException("Cannot add objects without a factory.");
174		}
175	0	Object obj = _factory.makeObject();
176
177	0	boolean success = true;
178	0	if(!_factory.validateObject(obj)) {
179	0	success = false;
180		} else {
181	0	_factory.passivateObject(obj);
182		}
183
184	0	boolean shouldDestroy = !success;
185	0	if(success) {
186	0	_pool.add(new SoftReference(obj, refQueue));
187	0	notifyAll(); // _numActive has changed
188		}
189
190	0	if(shouldDestroy) {
191		try {
192	0	_factory.destroyObject(obj);
193	0	} catch(Exception e) {
194		// ignored
195	0	}
196		}
197	0	}
198
199		/** Returns an approximation not less than the of the number of idle instances in the pool. */
200		public synchronized int getNumIdle() {
201	0	pruneClearedReferences();
202	0	return _pool.size();
203		}
204
205		/**
206		* Return the number of instances currently borrowed from this pool.
207		*
208		* @return the number of instances currently borrowed from this pool
209		*/
210		public synchronized int getNumActive() {
211	0	return _numActive;
212		}
213
214		/**
215		* Clears any objects sitting idle in the pool.
216		*/
217		public synchronized void clear() {
218	0	if(null != _factory) {
219	0	Iterator iter = _pool.iterator();
220	0	while(iter.hasNext()) {
221		try {
222	0	Object obj = ((SoftReference)iter.next()).get();
223	0	if(null != obj) {
224	0	_factory.destroyObject(obj);
225		}
226	0	} catch(Exception e) {
227		// ignore error, keep destroying the rest
228	0	}
229		}
230		}
231	0	_pool.clear();
232	0	pruneClearedReferences();
233	0	}
234
235		public void close() throws Exception {
236	0	super.close();
237	0	clear();
238	0	}
239
240		/**
241		* Sets the {@link PoolableObjectFactory factory} this pool uses
242		* to create new instances. Trying to change
243		* the <code>factory</code> while there are borrowed objects will
244		* throw an {@link IllegalStateException}.
245		*
246		* @param factory the {@link PoolableObjectFactory} used to create new instances.
247		* @throws IllegalStateException when the factory cannot be set at this time
248		*/
249		public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException {
250	0	assertOpen();
251	0	if(0 < getNumActive()) {
252	0	throw new IllegalStateException("Objects are already active");
253		} else {
254	0	clear();
255	0	_factory = factory;
256		}
257	0	}
258
259		/**
260		* If any idle objects were garbage collected, remove their
261		* {@link Reference} wrappers from the idle object pool.
262		*/
263		private void pruneClearedReferences() {
264		Reference ref;
265	0	while ((ref = refQueue.poll()) != null) {
266		try {
267	0	_pool.remove(ref);
268	0	} catch (UnsupportedOperationException uoe) {
269		// ignored
270	0	}
271		}
272	0	}
273
274		/** My pool. */
275	0	private List _pool = null;
276
277		/** My {@link PoolableObjectFactory}. */
278	0	private PoolableObjectFactory _factory = null;
279
280		/**
281		* Queue of broken references that might be able to be removed from <code>_pool</code>.
282		* This is used to help {@link #getNumIdle()} be more accurate with minimial
283		* performance overhead.
284		*/
285	0	private final ReferenceQueue refQueue = new ReferenceQueue();
286
287		/** Number of active objects. */
288	0	private int _numActive = 0;
289		}