（转）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 超过最大连接报异常了
*



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