对象池的容器：包含一个指定数量的对象。从池中取出一个对象时，它就不存在池中，直到它被放回。在池中的对象有生命周期：创建，验证，销毁，对象池有助于更好地管理可用资源，防止JVM内部大量临时小对象，频繁触发垃圾回收，造成系统暂停。有许多的使用示例。特别是在应用服务器数据源池，线程池等都是对象池的使用，下面情况适合使用对象池：
- 同样的对象高频率使用
- 对象太大消耗很多内存
- 对象初始化需要时间
- 对象内涉及IO操作 (Streams, Sockets, DB, etc.)
- 对象并不是线程安全时。
很多人使用 Apache Commons Pool.它有ObjectPool的接口，ObjectPoolFactory，PoolableObjectFactory和许多的实现。有addObject方法，borrowObject，invalidateObject，返回object添加，删除和返回对象。 PoolableObjectFactory定义对象池的操作行为，并提供各种回调。
但是Apache Commons Pool不是一个轻量开销的对象池，它很多方法采用了不建议使用的旧的Java的关键字synchronized。而Java 5中引入了Executor框架Java并发（多线程）。这里是最好的Executor框架。
package easypool; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; public abstract class ObjectPool<T> { private ConcurrentLinkedQueue<T> pool; private ScheduledExecutorService executorService; /** * Creates the pool. * * @param minIdle minimum number of objects residing in the pool */ public ObjectPool(final int minIdle) { // initialize pool initialize(minIdle); } /** * Creates the pool. * * @param minIdle minimum number of objects residing in the pool * @param maxIdle maximum number of objects residing in the pool * @param validationInterval time in seconds for periodical checking of minIdle / maxIdle conditions in a separate thread. * When the number of objects is less than minIdle, missing instances will be created. * When the number of objects is greater than maxIdle, too many instances will be removed. */ public ObjectPool(final int minIdle, final int maxIdle, final long validationInterval) { // initialize pool initialize(minIdle); // check pool conditions in a separate thread executorService = Executors.newSingleThreadScheduledExecutor(); executorService.scheduleWithFixedDelay(new Runnable() { @Override public void run() { int size = pool.size(); if (size < minIdle) { int sizeToBeAdded = minIdle - size; for (int i = 0; i < sizeToBeAdded; i++) { pool.add(createObject()); } } else if (size > maxIdle) { int sizeToBeRemoved = size - maxIdle; for (int i = 0; i < sizeToBeRemoved; i++) { pool.poll(); } } } }, validationInterval, validationInterval, TimeUnit.SECONDS); } /** * Gets the next free object from the pool. If the pool doesn't contain any objects, * a new object will be created and given to the caller of this method back. * * @return T borrowed object */ public T borrowObject() { T object; if ((object = pool.poll()) == null) { object = createObject(); } return object; } /** * Returns object back to the pool. * * @param object object to be returned */ public void returnObject(T object) { if (object == null) { return; } this.pool.offer(object); } /** * Shutdown this pool. */ public void shutdown() { if (executorService != null) { executorService.shutdown(); } } /** * Creates a new object. * * @return T new object */ protected abstract T createObject(); private void initialize(final int minIdle) { pool = new ConcurrentLinkedQueue<T>(); for (int i = 0; i < minIdle; i++) { pool.add(createObject()); } } }
package easypool; public class ExportingProcess { private String location; private long processNo = 0; public ExportingProcess(String location, long processNo) { this.location = location; this.processNo = processNo; // doing some time expensive calls / tasks // ... // for-loop is just for simulation for (int i = 0; i < Integer.MAX_VALUE; i++) { } System.out.println("Object with process no. " + processNo + " was created"); } public String getLocation() { return location; } public long getProcessNo() { return processNo; } @Override public String toString() { return "ExportingProcess{" + "processNo=" + processNo + '}'; } }
package easypool; public class ExportingTask implements Runnable { private ObjectPool<ExportingProcess> pool; private int threadNo; public ExportingTask(ObjectPool<ExportingProcess> pool, int threadNo) { this.pool = pool; this.threadNo = threadNo; } public void run() { // get an object from the pool ExportingProcess exportingProcess = pool.borrowObject(); System.out.println("Thread " + threadNo + ": Object with process no. " + exportingProcess.getProcessNo() + " was borrowed"); // do something // ... // for-loop is just for simulation for (int i = 0; i < 100000; i++) { } // return ExportingProcess instance back to the pool pool.returnObject(exportingProcess); System.out.println("Thread " + threadNo + ": Object with process no. " + exportingProcess.getProcessNo() + " was returned"); } }
package easypool; import org.junit.After; import org.junit.Before; import org.junit.Test; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; public class TestObjectPool { private ObjectPool<ExportingProcess> pool; private AtomicLong processNo = new AtomicLong(0); @Before public void setUp() { // Create a pool of objects of type ExportingProcess. Parameters: // 1) Minimum number of special ExportingProcess instances residing in the pool = 4 // 2) Maximum number of special ExportingProcess instances residing in the pool = 10 // 3) Time in seconds for periodical checking of minIdle / maxIdle conditions in a separate thread = 5. // When the number of ExportingProcess instances is less than minIdle, missing instances will be created. // When the number of ExportingProcess instances is greater than maxIdle, too many instances will be removed. // If the validation interval is negative, no periodical checking of minIdle / maxIdle conditions // in a separate thread take place. These boundaries are ignored then. pool = new ObjectPool<ExportingProcess>(4, 10, 5) { protected ExportingProcess createObject() { // create a test object which takes some time for creation return new ExportingProcess("/home/temp/", processNo.incrementAndGet()); } }; } @After public void tearDown() { pool.shutdown(); } @Test public void testObjectPool() { ExecutorService executor = Executors.newFixedThreadPool(8); // execute 8 tasks in separate threads executor.execute(new ExportingTask(pool, 1)); executor.execute(new ExportingTask(pool, 2)); executor.execute(new ExportingTask(pool, 3)); executor.execute(new ExportingTask(pool, 4)); executor.execute(new ExportingTask(pool, 5)); executor.execute(new ExportingTask(pool, 6)); executor.execute(new ExportingTask(pool, 7)); executor.execute(new ExportingTask(pool, 8)); executor.shutdown(); try { executor.awaitTermination(30, TimeUnit.SECONDS); } catch (InterruptedException e) { e.printStackTrace(); } } }
测试》》》》》》》》》》》》》》》》》》》》》
package test; public class StringFormat { public String format(String str) { return "formated:"+str; } }
package test; import org.apache.commons.pool2.BasePooledObjectFactory; import org.apache.commons.pool2.PooledObject; import org.apache.commons.pool2.impl.DefaultPooledObject; public class StringFormatFactory extends BasePooledObjectFactory<StringFormat> { @Override public StringFormat create() { System.out.println("create object"); return new StringFormat(); } /** * Use the default PooledObject implementation. */ @Override public PooledObject<StringFormat> wrap(StringFormat buffer) { return new DefaultPooledObject<StringFormat>(buffer); } /** * When an object is returned to the pool, clear the buffer. */ @Override public void passivateObject(PooledObject<StringFormat> pooledObject) { System.out.println("Object been returned to pool"); } // for all other methods, the no-op implementation // in BasePooledObjectFactory will suffice }
package test; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import java.util.List; import org.apache.commons.pool2.ObjectPool; import org.apache.commons.pool2.impl.GenericObjectPool; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; public class StringProcessor { private ObjectPool<StringFormat> pool; public StringProcessor(ObjectPool<StringFormat> pool) { this.pool = pool; } /** * Dumps the contents of the {@link Reader} to a String, closing the * {@link Reader} when done. */ public void process(List<String> strList) { for (String str : strList) { Thread thread = new StringProcessThread(pool, str); thread.start(); } //设置等待两秒，等待线程结束 try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } public static void main(String[] args) throws IOException { GenericObjectPoolConfig conf = new GenericObjectPoolConfig(); conf.setMaxTotal(3); conf.setMaxIdle(2); conf.setMinIdle(2); StringProcessor stringProcessor = new StringProcessor( new GenericObjectPool<StringFormat>(new StringFormatFactory(),conf)); List<String> strList = new ArrayList<String>(); strList.add("123"); strList.add("456"); strList.add("789"); strList.add("111"); strList.add("222"); strList.add("333"); stringProcessor.process(strList); } }
package test; import org.apache.commons.pool2.ObjectPool; public class StringProcessThread extends Thread { private ObjectPool<StringFormat> pool; private String toProcessStr; public StringProcessThread(ObjectPool<StringFormat> pool, String toProcessStr) { this.pool = pool; this.toProcessStr = toProcessStr; } public void run() { StringFormat stringFormat = null; try { stringFormat = pool.borrowObject(); String formattedStr = stringFormat.format(toProcessStr); System.out.println(formattedStr); } catch (Exception e) { e.printStackTrace(); } finally { try { if (stringFormat != null) { pool.returnObject(stringFormat); } } catch (Exception e) { e.printStackTrace(); } } } }