一个简单的数据库连接池实例

使用等待超时模式来构造一个简单的数据库连接池，实例中模拟从连接池中获取、使用和释放连接的过程，而客户端获取连接的过程被设定为等待超时的模式，也就是在1000毫秒内如果无法获取到可用连接，将会返回给客户端一个null。通过调节线程来模拟无法获取连接的场景。

代码清单如下：

ConnectionPool .java

package com.enfo.wd;import java.sql.Connection;import java.util.LinkedList;public class ConnectionPool {    private LinkedList<Connection> pool=new LinkedList<Connection>();    public ConnectionPool(int initialSize){        if(initialSize>0){            for(int i=0;i<initialSize;i++){                pool.addLast(ConnectionDriver.createConnection());            }        }    }    public void releaseConnection(Connection connection){        if(connection!=null){            synchronized (pool) {                //连接释放后需要进行通知，这样其他消费者能够感知到连接池中已经归还了一个连接                pool.addLast(connection);                pool.notifyAll();            }        }    }    //在mills内无法获取到连接，将会返回null    public Connection fetchConnection(long mills)throws Exception{        //完全超时        if(mills<=0){            while(pool.isEmpty()){                pool.wait();            }            return pool.removeFirst();        }else{            long future=System.currentTimeMillis()+mills;            long remaining=mills;            while(pool.isEmpty()&&remaining>0){                pool.wait(remaining);                remaining=future-System.currentTimeMillis();            }            Connection result=null;            if(!pool.isEmpty()){                result=pool.removeFirst();            }            return result;        }    }}

ConnectionDriver .java

package com.enfo.wd;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.sql.Connection;import java.util.concurrent.TimeUnit;public class ConnectionDriver {    static class ConnectionHandler implements InvocationHandler{        public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{            if(method.getName().equals("commit")){                TimeUnit.MILLISECONDS.sleep(100);            }            return null;        }    }    //创建一个connection的代理，在commit时休眠100毫秒    public static final Connection createConnection() {        return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(), new Class<?>[]{Connection.class},new ConnectionHandler());    }}

ConnectionTest .java

package com.enfo.wd;import java.sql.Connection;import java.util.concurrent.CountDownLatch;import java.util.concurrent.atomic.AtomicInteger;public class ConnectionTest {    static ConnectionPool pool=new ConnectionPool(10);    //保证所有的ConnetionRunner 能够同时开始    static CountDownLatch start=new CountDownLatch(1);    //mine线程将会等待 所有的ConnetionRunner 结束后才能继续执行    static CountDownLatch end;    public static void main(String[] args) throws Exception{        //通过修改线程数据量，观察数据变化        int threadCount=10;        end=new CountDownLatch(threadCount);        int count=20;        AtomicInteger got=new AtomicInteger();        AtomicInteger notGot=new AtomicInteger();        for(int i=0;i<threadCount;i++){            Thread thread=new Thread(new ConnetionRunner(count,got,notGot),"ConnectionRunnerThread");            thread.start();        }        start.countDown();        end.await();        System.out.println("total invoke:"+(threadCount*count));        System.out.println("got connection:"+got);        System.out.println("not got connection:"+notGot);    }    static class ConnetionRunner implements Runnable{        int count;        AtomicInteger got;        AtomicInteger notGot;        public ConnetionRunner(int count,AtomicInteger got,AtomicInteger notGot){            this.count=count;            this.got=got;            this.notGot=notGot;        }        public void run() {            try {                start.await();            } catch (InterruptedException e) {                e.printStackTrace();            }            while (count>0) {                try {                    Connection connection=(Connection) pool.fetchConnection(1000);                    if(connection!=null){                        try {                            //从线程池中获取连接，如果1000ms内无法获取到，将返回null                            //分别统计连接获取的数量got 和未获取到的数量notGot                            connection.createStatement();                            connection.commit();                        } finally {                            pool.releaseConnection(connection);                            got.incrementAndGet();                        }                    }else{                        notGot.incrementAndGet();                    }                } catch (Exception e) {                }finally{                    count--;                }            }            end.countDown();        }    }}