（转）JDBC连接池

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

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

   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 测试
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方法如下：


Java代码  收藏代码

  

 /** 
     * 测试连接池效率 
     */  
      
    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                                超过最大连接报异常了
*



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