java 数据库连接池

数据库连接池，是一种相当实用的应用程序。它可以保存、维护及创建用户所需的数据库连接。从而使得用户得到一个连接的时间降低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
 */

 http://www.cnblogs.com/jiushini/archive/2012/06/05/2535595.html