数据库连接池实践-CSDN博客

本文链接：https://blog.csdn.net/lauo1188/article/details/5599756

数据库连接池，是一种相当实用的应用程序。它可以保存、维护及创建用户所需的数据库连接。从而使得用户得到一个连接的时间降低90%以上。大大提升了数据库访问的反应时间。

这个是一个开源的代码。大家可以修改它、使用它。

希望我的代码能对大家有用。

此代码，经过1000数量级的多线程并发访问测试。在四核CPU下也进行了多线程测试。保证了连接池在真多线程上同步访问的安全性。

里面包含了一个公开的接口。使用这个接口里面的函数。可以轻易创建使用数据库连接池服务。

使用一个守护线程维护这个连接池，完全自动化。

下载连接：http://download.csdn.net/user/lauo1188

连接池接口类：

package mysql; import java.sql.*; import java.sql.ResultSet; public interface Pool { public boolean start(String dbname,String user,String psw); //启动数据库连接池服务 //以下start函数将允许用户设置最低空闲连接数，最高空闲连接数,最大连接数 public boolean start(int lows,int maxs,int maxc,String dbname,String user,String psw); public Connection getConnection(); //得到连接器 public boolean freeConnection(Connection con);//将连接返回到连接池中 public boolean close(); //清除连接池，并且关闭它（使之变得不可用） }

第一个实现类：VectorPool

/** * @(#)Pool.java * * * @author lauo * @version 1.00 2010/5/15 * * 测试完成于2010-5-16 22:40分 */ package mysql; import mysql.*; import java.sql.*; import java.util.*; /* *这里将实现ConnectionPool接口 */ public class VectorPool extends Thread implements Pool { protected final boolean debug = false; //是否debug态（如是输出debug状态信息) protected boolean init = false;//是否已经将setting初始化 //timeDiff 一个连接超过此时间未使用过，则需要更新此连接----1小时 protected final long timeDiff = 60*60*1000 ;//1小时60分钟，1分钟60秒，1秒1000毫秒 protected int lows = 20 ; //连接池的最小空闲连接数 protected int maxs = 100 ; //连接池的最大空闲连接数 protected int maxc = 100; protected String dbname = null; protected String user = null; protected String psw = null; protected Integer conCount = 0; //这个是静态的。当前连接数 //下面是连接保存的池 protected Vector<ConInfo> pool = new Vector<ConInfo>(); public VectorPool() { } public void start() { } //得到当前连接数 protected int getConCount() { return conCount; } /* *设置数据库连接的基本参数 */ public synchronized boolean start(String db,String u,String p) { if(false == init && null != pool)//如果未初始化，且连接池可用 { dbname = db; user = u; psw = p; if(test()) { init = true; super.start(); return true; } else return false; } else return false; } public synchronized boolean start(int l,int m,int mc,String db,String u,String p) { if(l<0 || m<0 ||l>=m || m>mc)//0<l<m<=mc return false; if(false == init && null != pool)//如果未初始化，且连接池可用 { dbname = db; user = u; psw = p; if(test()) { init = true; lows = l<5?5:l; //这里允许的最小的值为5 maxs = m<10?10:m; //这里允许的最小的值为10 maxc = mc<20 ?20:mc;//这里允许的连接数 super.start(); return true; } else return false; } else return false; } /* *从连接池得到一个连接 */ public synchronized Connection getConnection() { if(init) { ConInfo c = getOneConnection(); return c!=null?c.con:null;//安全得到一个连接 } else return null; } /* *得到一个连接，包含了lastTime信息 */ protected synchronized ConInfo getOneConnection() { if(pool.size()!=0) { return pool.remove(0); } else //如果连接池为空，创建新的连接 { if(debug) System.out.println("new connection!"); return newConInfo(); } } /* *将一个连接放回到连接池中 */ public synchronized boolean freeConnection(Connection con) { if(init==false || con == null )//当没有init或者已经close之后不应该free它进来。 return false; ConInfo c = new ConInfo(con);//调用了ConInfo的构造函数 pool.addElement(c); return true; } /* *将内容清空 *且将本连接池对象置为无用状态 */ public synchronized boolean close() { if(init) { init = false; for(int i = 0; i <pool.size();i++) pool.get(i).close(); pool.clear(); pool = null;//将此连接池置为无用状态。如果要新的链接池，重新创建链接池对象 dbname = null; user = null; psw = null; return true; } else return false; } /* *下面将是一个一线程执行体，当start连接池服务之后，由它来维护 *连接池里面的连接，从而保证他们能被正确的创建、注销 * */ public void run() { final long sleepTime = 2*1000 ; //2秒 final long refreshTime = 10*60*1000; //10分钟运行一次。连接是否应该被更新 final long lowsCheckTime = 2*1000;//10秒检查一次。最低连接数检查间隔时间 final long maxsCheckTime = 60*1000;//1分钟检查一次。最大连接数时间 long loop = 0; while(true) { if(loop%refreshTime == 0) { if(debug) System.out.println("call refresh:"+pool.size()); refreshByTimeDiff(); } if(loop%maxsCheckTime == 0) { if(debug) System.out.println("call toMaxs:"+pool.size()); toMaxs(); } if(loop%lowsCheckTime == 0) { if(debug) System.out.println("conCnt:"+conCount+" call toLows:"+pool.size()); toLows(); } loop += sleepTime;//更新loop的时间。 try{ sleep(sleepTime); } catch(Exception e){ e.printStackTrace(); stop(); } } } /* *使过小的空闲连接数恢复到lows */ protected void toLows() { int size = pool.size(); /* *这里要避免直接使用pool.size进行判断 *当连接一直被get出去之后，size很难达到lows，故此 */ for(;size<lows;size++) { if(debug) System.out.println("toLows is running!"); ConInfo c = newConInfo(); if(c!=null) synchronized(pool) { pool.addElement(c); } } } /* *使过多的空闲连接数恢复到maxs; */ protected void toMaxs() { int size = pool.size(); for(;size>maxs;size--) { if(debug) System.out.println("toMaxs is running!"); try{ getConnection().close(); synchronized(conCount)//这里修改要同步好。 { conCount --; } } catch(Exception e) { e.printStackTrace(); } } } /* *查找当前的连接池，找到timeDiff时间内未使用过的连接，删除它们，如果连接数不足，将由toLows补齐 *一个危险的线程不安全函数 */ public void refreshByTimeDiff() { Calendar nowTime = Calendar.getInstance(); long now = nowTime.getTimeInMillis(); for(int i=0;i<pool.size();i++) { ConInfo c = getOneConnection(); if(now - c.lastTime.getTimeInMillis() >=timeDiff)//删除它们 { if(debug) System.out.println("refresh the pool!,,,,,,,,"); synchronized(pool)//获得pool的锁 { pool.remove(i).close();//使用了ConInfo中的关闭函数 } } } } /* *一个测试数据库连接是否可用的函数 */ protected boolean test() { int cnt = 10; Connection c; do{ c = newConnection(); cnt -- ; }while(c==null && cnt>=0); if(c!=null) { (new ConInfo(c)).close(); return true; } else return false; } /* *下面为内置的类，用于表明一个连接最后使用时间 */ class ConInfo { protected Calendar lastTime; //连接最后使用时间 protected Connection con = null; //对应的connection public ConInfo(Connection c) { con = c; lastTime = Calendar.getInstance(); } public synchronized void close() { try { if(con!=null) con.close(); synchronized(conCount) { conCount-=con!=null?1:0; } lastTime = null; } catch(Exception e) { e.printStackTrace(); } } } /* *创建一个新的连接 */ protected Connection newConnection() { try { Class.forName("com.mysql.jdbc.Driver"); int cnt = 0; Connection c = null; synchronized(conCount) { if(conCount<=maxc)//当连接数没超过既定最大连接数时 do { try{ c = DriverManager.getConnection(dbname,user,psw); }catch(Exception es){c=null;if(debug) System.out.println("create new connection error!");} cnt++; }while(null == c && cnt<3); conCount+=c!=null?1:0; } return c;//创建一个新的connection } catch(Exception e) { e.printStackTrace(); return null; } } /* *得到一个新的连接 */ protected ConInfo newConInfo() { Connection c = newConnection(); if(c==null) return null; return new ConInfo(c); } /* *测试函数main */ public static void main(String[] argvs) { VectorPool pool = new VectorPool(); Connection con = null; boolean flag = pool.start("jdbc:mysql://localhost/finance","root",""); int cnt = 10000;//1万次 long t0 = Calendar.getInstance().getTimeInMillis(); /测试选项 final boolean tflag = true ;//如为true 为使用连接池否则直接创建一个新连接。 // while(flag){ con = tflag ? pool.getConnection():pool.newConnection();//; try { Statement stm = con.createStatement(); ResultSet rev = stm.executeQuery("select * from user"); while(false && rev!=null && rev.next()) { System.out.println(rev.getString("id")); } stm.close(); } catch(Exception e) { e.printStackTrace(); } // if(Math.abs(Math.random())%10<4) if(tflag)//使用完之后要释放，否则会出大问题 pool.freeConnection(con); try{ if(!tflag) con.close();//释放连接当不用pool时 } catch(Exception exx) { exx.printStackTrace(); } /* try{ sleep(100); ///间隔时间 } catch(Exception ee) { ee.printStackTrace(); } */ //System.out.println("cnt:"+cnt); // System.out.println("con_Cnt:"+pool.getConCount()); if(--cnt<0) break; } System.out.println("used time:"+(Calendar.getInstance().getTimeInMillis()-t0)); } } /* * use the pool; cnt:3 cnt:2 cnt:1 cnt:0 used time:11286 ---用了11.286秒 cnt:9 cnt:8 cnt:7 cnt:6 cnt:5 cnt:4 cnt:3 cnt:2 cnt:1 cnt:0 used time:129376 用了129.376秒（多了整整十倍）。再测试一次： cnt:1 cnt:0 used time:7871 ---used the pool 7.871秒 cnt:4 cnt:3 cnt:2 cnt:1 cnt:0 used time:100084 ----create the connection one by one 100.084秒 */

第二个实现类：ListPool

/* * @(#)Pool.java * * * @author * @version 1.00 2010/5/15 */ package mysql; import mysql.*; import java.sql.*; import java.util.*; /* *这里将实现ConnectionPool接口 */ public class ListPool extends Thread implements Pool { protected final boolean debug = false; //是否debug态（如是输出debug状态信息) protected boolean init = false;//是否已经将setting初始化 //timeDiff 一个连接超过此时间未使用过，则需要更新此连接----1小时 protected final long timeDiff = 60*60*1000 ;//1小时60分钟，1分钟60秒，1秒1000毫秒 protected int lows = 20 ; //连接池的最小空闲连接数 protected int maxs = 100 ; //连接池的最大空闲连接数 protected int maxc = 100; protected String dbname = null; protected String user = null; protected String psw = null; protected Integer conCount = 0; //这个是静态的。当前连接数 //下面是连接保存的池 protected LinkedList<ConInfo> pool = new LinkedList<ConInfo>(); public ListPool() { } public void start() { } //得到当前连接数 protected int getConCount() { return conCount; } /* *设置数据库连接的基本参数 */ public synchronized boolean start(String db,String u,String p) { if(false == init && null != pool)//如果未初始化，且连接池可用 { dbname = db; user = u; psw = p; if(test()) { init = true; super.start(); return true; } else return false; } else return false; } public synchronized boolean start(int l,int m,int mc,String db,String u,String p) { if(l<0 || m<0 ||l>=m || m>mc)//0<l<m<=mc return false; if(false == init && null != pool)//如果未初始化，且连接池可用 { dbname = db; user = u; psw = p; if(test()) { init = true; lows = l<5?5:l; //这里允许的最小的值为5 maxs = m<10?10:m; //这里允许的最小的值为10 maxc = mc<20 ?20:mc;//这里允许的连接数 super.start(); return true; } else return false; } else return false; } /* *从连接池得到一个连接 */ public synchronized Connection getConnection() { if(init) { ConInfo c = getOneConnection(); return c!=null?c.con:null;//安全得到一个连接 } else return null; } /* *得到一个连接，包含了lastTime信息 */ protected synchronized ConInfo getOneConnection() { if(pool.size()!=0) { return pool.remove(0); } else //如果连接池为空，创建新的连接 { if(debug) System.out.println("new connection!"); return newConInfo(); } } /* *将一个连接放回到连接池中 */ public synchronized boolean freeConnection(Connection con) { if(init==false || con == null )//当没有init或者已经close之后不应该free它进来。 return false; ConInfo c = new ConInfo(con);//调用了ConInfo的构造函数 pool.add(c); return true; } /* *将内容清空 *且将本连接池对象置为无用状态 */ public synchronized boolean close() { if(init) { init = false; for(int i = 0; i <pool.size();i++) pool.get(i).close(); pool.clear(); pool = null;//将此连接池置为无用状态。如果要新的链接池，重新创建链接池对象 dbname = null; user = null; psw = null; return true; } else return false; } /* *下面将是一个一线程执行体，当start连接池服务之后，由它来维护 *连接池里面的连接，从而保证他们能被正确的创建、注销 * */ public void run() { final long sleepTime = 2*1000 ; //2秒 final long refreshTime = 10*60*1000; //10分钟运行一次。连接是否应该被更新 final long lowsCheckTime = 2*1000;//10秒检查一次。最低连接数检查间隔时间 final long maxsCheckTime = 60*1000;//1分钟检查一次。最大连接数时间 long loop = 0; while(true) { if(loop%refreshTime == 0) { if(debug) System.out.println("call refresh:"+pool.size()); refreshByTimeDiff(); } if(loop%maxsCheckTime == 0) { if(debug) System.out.println("call toMaxs:"+pool.size()); toMaxs(); } if(loop%lowsCheckTime == 0) { if(debug) System.out.println("conCnt:"+conCount+" call toLows:"+pool.size()); toLows(); } loop += sleepTime;//更新loop的时间。 try{ sleep(sleepTime); } catch(Exception e){ e.printStackTrace(); stop(); } } } /* *使过小的空闲连接数恢复到lows */ protected void toLows() { int size = pool.size(); /* *这里要避免直接使用pool.size进行判断 *当连接一直被get出去之后，size很难达到lows，故此 */ for(;size<lows;size++) { if(debug) System.out.println("toLows is running!"); ConInfo c = newConInfo(); if(c!=null) synchronized(pool) { pool.add(c); } } } /* *使过多的空闲连接数恢复到maxs; */ protected void toMaxs() { int size = pool.size(); for(;size>maxs;size--) { if(debug) System.out.println("toMaxs is running!"); try{ getConnection().close(); synchronized(conCount)//这里修改要同步好。 { conCount --; } } catch(Exception e) { e.printStackTrace(); } } } /* *查找当前的连接池，找到timeDiff时间内未使用过的连接，删除它们，如果连接数不足，将由toLows补齐 *一个危险的线程不安全函数 */ public void refreshByTimeDiff() { Calendar nowTime = Calendar.getInstance(); long now = nowTime.getTimeInMillis(); for(int i=0;i<pool.size();i++) { ConInfo c = getOneConnection(); if(now - c.lastTime.getTimeInMillis() >=timeDiff)//删除它们 { if(debug) System.out.println("refresh the pool!,,,,,,,,"); synchronized(pool)//获得pool的锁 { pool.remove(i).close();//使用了ConInfo中的关闭函数 } } } } /* *一个测试数据库连接是否可用的函数 */ protected boolean test() { int cnt = 10; Connection c; do{ c = newConnection(); cnt -- ; }while(c==null && cnt>=0); if(c!=null) { (new ConInfo(c)).close(); return true; } else return false; } /* *下面为内置的类，用于表明一个连接最后使用时间 */ class ConInfo { protected Calendar lastTime; //连接最后使用时间 protected Connection con = null; //对应的connection public ConInfo(Connection c) { con = c; lastTime = Calendar.getInstance(); } public synchronized void close() { try { if(con!=null) con.close(); synchronized(conCount) { conCount-=con!=null?1:0; } lastTime = null; } catch(Exception e) { e.printStackTrace(); } } } /* *创建一个新的连接 */ protected Connection newConnection() { try { Class.forName("com.mysql.jdbc.Driver"); int cnt = 0; Connection c = null; synchronized(conCount) { if(conCount<=maxc)//当连接数没超过既定最大连接数时 do { try{ c = DriverManager.getConnection(dbname,user,psw); }catch(Exception es){c=null;if(debug) System.out.println("create new connection error!");} cnt++; }while(null == c && cnt<3); conCount+=c!=null?1:0; } return c;//创建一个新的connection } catch(Exception e) { e.printStackTrace(); return null; } } /* *得到一个新的连接 */ protected ConInfo newConInfo() { Connection c = newConnection(); if(c==null) return null; return new ConInfo(c); } /* *测试函数main */ public static void main(String[] argvs) { ListPool pool = new ListPool(); Connection con = null; boolean flag = pool.start("jdbc:mysql://localhost/finance","root",""); int cnt = 10000;//1万次 long t0 = Calendar.getInstance().getTimeInMillis(); /测试选项 final boolean tflag = true ;//如为true 为使用连接池否则直接创建一个新连接。 // while(flag){ con = tflag ? pool.getConnection():pool.newConnection();//; try { Statement stm = con.createStatement(); ResultSet rev = stm.executeQuery("select * from user"); while(false && rev!=null && rev.next()) { System.out.println(rev.getString("id")); } stm.close(); } catch(Exception e) { e.printStackTrace(); } // if(Math.abs(Math.random())%10<4) if(tflag)//使用完之后要释放，否则会出大问题 pool.freeConnection(con); try{ if(!tflag) con.close();//释放连接当不用pool时 } catch(Exception exx) { exx.printStackTrace(); } /* try{ sleep(100); ///间隔时间 } catch(Exception ee) { ee.printStackTrace(); } */ // System.out.println("cnt:"+cnt); // System.out.println("con_Cnt:"+pool.getConCount()); if(--cnt<0) break; } System.out.println("used time:"+(Calendar.getInstance().getTimeInMillis()-t0)); } } /* * use the pool; cnt:3 cnt:2 cnt:1 cnt:0 used time:11286 ---用了11.286秒 cnt:9 cnt:8 cnt:7 cnt:6 cnt:5 cnt:4 cnt:3 cnt:2 cnt:1 cnt:0 used time:129376 用了129.376秒（多了整整十倍）。 -------listPool used time:10995 */

一个测试类：testPool

/** * @(#)testPool.java * * * @author * @version 1.00 2010/5/15 */ package mysql; import java.sql.*; import java.util.*; import mysql.*; public class testPool extends Thread { protected String dbname = null, user = null, psw = null; Pool pool= null; boolean flag = true; public testPool(Pool p,boolean f,String d,String u,String pw) { pool = p; flag = f; dbname = d; user = u; psw = pw; } public void start(int n) { while(n-->0) { super.start(); } } public void run() { long id = this.getId(); Connection con = null; int cnt = 100;//1万次 long t0 = Calendar.getInstance().getTimeInMillis(); /测试选项 final boolean tflag = true ;//如为true 为使用连接池否则直接创建一个新连接。 // while(flag){ con = tflag ? pool.getConnection():newConnection();//; if(con == null) continue; try { Statement stm = con.createStatement(); ResultSet rev = stm.executeQuery("select * from user"); while(false && rev!=null && rev.next()) { System.out.println(rev.getString("id")); } stm.close(); } catch(Exception e) { e.printStackTrace(); } // if(Math.abs(Math.random())%10<4) if(tflag)//使用完之后要释放，否则会出大问题 pool.freeConnection(con); try{ if(!tflag) con.close();//释放连接当不用pool时 } catch(Exception exx) { exx.printStackTrace(); } /* try{ sleep(100); ///间隔时间 } catch(Exception ee) { ee.printStackTrace(); } */ // System.out.println("threadId:"+id+" cnt:"+cnt); //System.out.println("con_Cnt:"+((Pool)pool).getConCount()); if(--cnt<0) break; } System.out.println("used time:"+(Calendar.getInstance().getTimeInMillis()-t0)); } public Connection newConnection() { try { Class.forName("com.mysql.jdbc.Driver"); int cnt = 0; Connection c = null; do { c = DriverManager.getConnection(dbname,user,psw); cnt++; }while(null == c && cnt<15); if(null == c) return null; else return c;//创建一个新的connection } catch(Exception e) { e.printStackTrace(); return null; } } public static void main(String argv[]) { Pool pool = null; boolean who = true; pool = who ? new VectorPool() : new ListPool(); boolean flag = pool.start(20,30,100,"jdbc:mysql://localhost/finance","root",""); int cnt = 100; while(cnt-->0) { testPool p = new testPool(pool,flag,"jdbc:mysql://localhost/finance","root",""); p.start(); } } } /* *测试结果表明，当100*100时，Pool要略优于ListPool（差异不大，如下） * Pool: used time:4967 used time:4997 used time:5017 used time:5218 used time:5558 used time:4937 used time:4977 used time:5107 used time:5378 used time:5368 used time:5408 2: used time:5779 used time:6049 used time:6269 used time:6269 used time:6209 used time:6009 ListPool used time:5788 used time:6148 used time:5589 used time:5819 used time:5619 used time:6089 used time:5558 used time:6029 used time:5629 2 used time:5158 used time:5188 used time:5808 used time:5117 used time:5648 used time:5718 used time:5668 used time:5868 used time:5908 used time:5948 used time:5958 used time:5828 used time:5969 used time:5979 used time:6329 used time:6089 */