JDBC连接池
很早的时候就知道要提高访问数据的效率，连接池是其中一个最重要的环节。虽然知道其原理就是将连接提前建立好放在一个池子里，然后当需要的时候直接使用用建立好的连接，而不用 每次都新建，使用完后还会去，而不用关闭，刚开始的时候总是不太明白，或者说不知道他是如何储存连接，如何使用连接。
最近就花了点时间，写了个简单的连接池，就重点介绍下连接池这个类：
DBConnPool.java
DBConnProperties.java，这个就是存放数据库的一些连接参数。（详细见附件）
然后我用多线程写了一个测试用例
TestThread.java 测试
Java代码 收藏代码
Test.java的main方法如下：
Java代码 收藏代码
其中还用直接用直接连接的测试用例（见附近）
测试结果如下：
* 同时执行个数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 超过最大连接报异常了
*
对于结果的疑问，用连接池的方式，比直接连接的方式效率要高多了，这是无容置疑的，可是，当我增大连接池的数量时，那么当用多个访问时，效率且基本上没什么变化，这是为什么呢？，按道理池里面的连接数越多，速度应该越快，时间就越短，为什么没有这种效果，希望有人能指点小弟！
最近就花了点时间，写了个简单的连接池，就重点介绍下连接池这个类：
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 超过最大连接报异常了
*
对于结果的疑问，用连接池的方式，比直接连接的方式效率要高多了，这是无容置疑的，可是，当我增大连接池的数量时，那么当用多个访问时，效率且基本上没什么变化，这是为什么呢？，按道理池里面的连接数越多，速度应该越快，时间就越短，为什么没有这种效果，希望有人能指点小弟！