连接池实现原理及效率上的一点疑问

 很早的时候就知道要提高访问数据的效率，连接池是其中一个最重要的环节。虽然知道其原理就是将连接提前建立好放在一个池子里，然后当需要的时候直接使用用建立好的连接，而不用 每次都新建，使用完后还会去，而不用关闭，刚开始的时候总是不太明白，或者说不知道他是如何储存连接，如何使用连接。

   最近就花了点时间，写了个简单的连接池，就重点介绍下连接池这个类：

   DBConnPool.java

public class DBConnPool  {
	private String url;
	private DBConnProperties DBconnpro;
	private  Vector<Connection> connpool=new Vector();   //存放连接
	private Vector<DBConnPool> waitconn=new Vector();   //存放等待连接的线程
	private int connpool_outsize=0;  //连接正在使用的数量
	public DBConnPool(String url){
		this.url=url;
		init();
	}
	/**
	 * 从连接池中获取连接
	 * @return
	 */
	public Connection getConn() {
		Connection conn=null;
		synchronized(this){
			if(connpool.isEmpty()){
				if(connpool_outsize+connpool.size()>=DBconnpro.getConnectionMax()){
                      //当连接池为空，并且当前使用连接数已经大于最大连接数时，当前连接线程进入等待，直到有新空连接时继续执行
					try {
						waitconn.add(this);   //将当前连接请求放入等待队列
//						System.out.println("连接超过最大数,进入等待");
						wait();
//						System.out.println("继续执行");
						return getConn();  //被唤醒后，重新请求获取连接

					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}else{
					//当连接池为空，并且连接数已经大于最大连接数时，新建连接
					conn=newConn();
					connpool_outsize++;
					return conn;
				}
			}
			if(!connpool.isEmpty()){
				//当连接池不为空时，从连接池获得连接
				conn=connpool.remove(0);
				connpool_outsize++;
				return conn;
			}

		}
		return conn;
	}

	/**
	 * 连接使用完毕后，放回连接池
	 * @param conn
	 */
	public  void returnConn(Connection conn) {
		synchronized(this){
			if(!waitconn.isEmpty()){
                //当有等待队列中有等待的连接时，将连接放入连接池，一提供给等待连接队列使用
				DBConnPool dbconnpool=waitconn.remove(0);
//				System.out.println("有新连接释放");
				connpool.add(conn);
				connpool_outsize--;
				dbconnpool.notify();

			}else{
				if(connpool_outsize+connpool.size()>DBconnpro.getConnectionMin()){
					//当有等待队列中没有有等待的连接，并且当前使用连接数已经大于最小连接数时，将连接(connection)关闭连接
					try {
						connpool_outsize--;
						conn.close();
					} catch (SQLException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}					
				}else{
					//当有等待队列中没有有等待的连接，并且当前使用连接数已经小于或等于最小连接数时，将连接放回连接池
					connpool.add(conn);
					connpool_outsize--;
				}
			}

		}

	}

	/**
	 * 创建一个新的连接
	 * @return
	 */
	public Connection newConn() {
		Connection conn=null;
		try {
			Class.forName(DBconnpro.getServerdbdriver());
			conn=DriverManager.getConnection(DBconnpro.geturl(),DBconnpro.getServerdbname(),DBconnpro.getServerdbpassword());
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return conn;
	}

	/**
	 * 初始化连接池
	 */
	public void init() {
		this.DBconnpro=new DBConnProperties(url);
		connpool=new Vector();
		for(int i=0;i<DBconnpro.getConnectionMin();i++){
			Connection conn=newConn();
			connpool.add(conn);
		}
	}
}

 

   DBConnProperties.java，这个就是存放数据库的一些连接参数。（详细见附件）

   然后我用多线程写了一个测试用例

   TestThread.java 测试

	/**
	 * 测试连接池效率
	*/
	public DBConnPool connpool;
	public Chaxun(int i,DBConnPool connpool){

		this.i=i;
		this.connpool=connpool;
	}

	public void run(){
//		System.out.println("开始执行第"+i+"个线程");

		Connection conn=connpool.getConn();
		PreparedStatement pstm=null;
		ResultSet rs=null;
		try {

			pstm=conn.prepareStatement("select * from t_user");
			rs=pstm.executeQuery();
			while(rs.next()){
//				System.out.println(rs.getString("name"));
			}
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			try {
				if(rs!=null){
					rs.close();
				}
				if(pstm!=null){
					pstm.close();
				}
				if(connpool!=null){
					connpool.returnConn(conn);
				}
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}
//		System.out.println("第"+i+"个线程线程执行完毕,时间为："+(new Date()).getTime());
//		System.out.println("总共执行时间为："+((new Date()).getTime()-Test.times));
		logger.info(i+"："+((new Date()).getTime()-Test.times));
	}
 

  

 Test.java的main方法如下：

 

		/**
		 * 测试连接池效率
		 */
		
		DBConnPool dbconnpool=new DBConnPool("src/system.properties");
		times=(new Date()).getTime();	
		System.out.println("第一次执行时间为："+times);
		for(int i=0;i<10000;i++){	
			Thread thread=new TestThread(i,dbconnpool);
			thread.start();				
		}

 

其中还用直接用直接连接的测试用例（见附近）

测试结果如下：

 *                                                       同时执行个数50个的 时间         同时执行个数200个的 时间         同时执行个数5000个的 时间           同时执行个数10000个的 时间    
 * 连接池(最大连接2，最小连接1)                     297ms                                     453ms                                      6375ms                               13906ms              
 * 连接池(最大连接6，最小连接3)                     281ms                                     469ms                                      5344ms                               11235ms                  
 * 连接池(最大连接8，最小连接4)                     297ms                                     485ms                                      5890ms                               11235ms                
 * 连接池(最大连接10，最小连接5)                    328ms                                    516ms                                     5438ms                                11469ms                    
 * 连接池(最大连接20，最小连接10)                   390ms                                  563ms                                    5829ms                                   11890ms                   
 * 连接池(最大连接30，最小连接20)                   375ms                                   562ms                                    5766ms                                  11141ms                

 

  * 普通连接方式                                              1750ms                                  4922ms                                超过最大连接报异常了
 *

 

   对于结果的疑问，用连接池的方式，比直接连接的方式效率要高多了，这是无容置疑的，可是，当我增大连接池的数量时，那么当用多个访问时，效率且基本上没什么变化，这是为什么呢？，按道理池里面的连接数越多，速度应该越快，时间就越短，为什么没有这种效果，希望有人能指点小弟！