读commons-pool源码

目前只读了BaseObjectPool这部分的源码。下面是pool中几个重要的类，和自己业务类之间的UML关系图。


接口：
ObjectPool 定义实际池对象需要有哪些方法，
PoolableObjectFactory 定义了创建被池化对象的工厂接口
在实际开发中我们需要定义两个自己的业务类：
1、具体池化类
2、池化类的工厂类

package org.xiaoqingp.test.pool;

import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.PoolableObjectFactory;
import org.apache.commons.pool.impl.GenericObjectPool;

public class TestGenericObjectPool {

	private static int cCount = 0;

	private static synchronized String getCName() {
		return "runner_" + cCount++;
	}

	/**
	 * 内部类，模拟connect
	 * 
	 * @author xiaoqingP
	 * 
	 */
	private class MyConnect {
		private String name;
		private boolean connected;

		public MyConnect(String name) {
			System.out.println("初始化 " + name + ":" + connected);
			this.name = name;
		}

		public void connect() {
			this.connected = true;
		}

		public void close() {
			this.connected = false;
			System.out.println("关闭 " + name + ": " + connected);
		}

		public boolean isConnected() {
			return this.connected;
		}

		public String getName() {
			return this.name;
		}

		public void print(String str) {
			System.out.println("打印 " + this.name + "   "+str);
		}
	}

	/**
	 * 内部类，池对象创建工厂
	 * 
	 * @author xiaoqingP
	 * 
	 */
	private class MyConnectionPoolableObjectFactory implements
			PoolableObjectFactory<MyConnect> {

		@Override
		public void activateObject(MyConnect obj) throws Exception {
			obj.print("激活对象");
		}

		@Override
		public void destroyObject(MyConnect obj) throws Exception {
			obj.print("销毁对象");
		}

		@Override
		public MyConnect makeObject() throws Exception {
			MyConnect c = new MyConnect(TestGenericObjectPool.getCName());
			return c;
		}

		@Override
		public void passivateObject(MyConnect obj) throws Exception {
			obj.print("钝化对象");
		}

		@Override
		public boolean validateObject(MyConnect obj) {
			obj.print("验证对象");
			return true;
		}

	}

	private class MyTask implements Runnable {

		private ObjectPool<MyConnect> pool;

		public MyTask(ObjectPool<MyConnect> pool) {
			this.pool = pool;
		}

		public void run() {
			MyConnect myConn = null;
			try {
				myConn = pool.borrowObject();
				try {
					myConn.print("借对象");
				} catch (Exception ex) {
					pool.invalidateObject(myConn);
					myConn = null;
				}
				Thread.sleep(10L * 1000L);// 睡10秒钟
			} catch (Exception ex) {
				System.out.println("Cannot borrow connection from pool.");
				ex.printStackTrace();
			} finally {
				if (myConn != null) {
					try {
						//return 时会调用钝化方法
						pool.returnObject(myConn);
					} catch (Exception ex) {
						System.out
								.println("Cannot return connection from pool.");
						ex.printStackTrace();
					}
				}
			}
		}

	}

	/**
	 * 测试连接池数量不够，等待超时
	 */
	public static void main(String... strings) {
		TestGenericObjectPool test = new TestGenericObjectPool();
		PoolableObjectFactory<MyConnect> factory = test.new MyConnectionPoolableObjectFactory();
		GenericObjectPool.Config config = new GenericObjectPool.Config();
		config.lifo = false;
		config.maxActive = 5;
		config.maxIdle = 5;
		config.minIdle = 1;
		config.maxWait = 5 * 1000;

		GenericObjectPool<MyConnect> pool = new GenericObjectPool<MyConnect>(
				factory, config);
		for (int i = 0; i < 10; i++) {
			Thread thread = new Thread(test.new MyTask(pool));
			thread.start();
		}

	}

}

输出结果：
初始化 runner_0:false
初始化 runner_4:false
初始化 runner_3:false
初始化 runner_2:false
初始化 runner_1:false
打印 runner_0   激活对象
打印 runner_3   激活对象
打印 runner_3   借对象
打印 runner_1   激活对象
打印 runner_1   借对象
打印 runner_2   激活对象
打印 runner_2   借对象
打印 runner_4   激活对象
打印 runner_4   借对象
打印 runner_0   借对象
Cannot borrow connection from pool.
Cannot borrow connection from pool.
Cannot borrow connection from pool.
java.util.NoSuchElementException: Timeout waiting for idle object
Cannot borrow connection from pool.
Cannot borrow connection from pool.
at org.apache.commons.pool.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:1174)
at org.xiaoqingp.test.pool.TestGenericObjectPool$MyTask.run(TestGenericObjectPool.java:101)
at java.lang.Thread.run(Thread.java:619)
java.util.NoSuchElementException: Timeout waiting for idle object
at org.apache.commons.pool.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:1174)
at org.xiaoqingp.test.pool.TestGenericObjectPool$MyTask.run(TestGenericObjectPool.java:101)
at java.lang.Thread.run(Thread.java:619)
java.util.NoSuchElementException: Timeout waiting for idle object
at org.apache.commons.pool.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:1174)
at org.xiaoqingp.test.pool.TestGenericObjectPool$MyTask.run(TestGenericObjectPool.java:101)
at java.lang.Thread.run(Thread.java:619)
java.util.NoSuchElementException: Timeout waiting for idle object
at org.apache.commons.pool.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:1174)
at org.xiaoqingp.test.pool.TestGenericObjectPool$MyTask.run(TestGenericObjectPool.java:101)
at java.lang.Thread.run(Thread.java:619)
java.util.NoSuchElementException: Timeout waiting for idle object
at org.apache.commons.pool.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:1174)
at org.xiaoqingp.test.pool.TestGenericObjectPool$MyTask.run(TestGenericObjectPool.java:101)
at java.lang.Thread.run(Thread.java:619)
打印 runner_1   钝化对象
打印 runner_4   钝化对象
打印 runner_2   钝化对象
打印 runner_3   钝化对象
打印 runner_0   钝化对象

池中最大对象最有5个，单初始化了5个后，在过了最大等待时间borrow对象时就会报错。
上面的测试borrow对象时，会调用PoolableObjectFactory的makeOjbect方法创建对象，再调用activateObject方法，在return对象时，会调用passivateObject方法。