用JAVA 实现一个简版数据库连接池

在JAVA工程师的面试当中，数据库连接池的实现，肯定也是多线程等待超时模式的一个重要实现案例，通过网上的查阅，对数据连接池有了一定的了解，然后就自己写了一个简陋版，以供理解。
下面贴出代码：
1.创建数据库连接的驱动类，在真实环境中有数据库厂商提供驱动包。如mysql：mysql-connectorxxxx.jar
ConnectDriver(通过动态代理，对commit方法进行装饰):

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{
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

if(method.getName().equals("commit")){
System.out.println("I am commit!!!");
TimeUnit.MILLISECONDS.sleep(100);
}
return null;
}
}

public static final Connection createConnection(){

return (Connection) Proxy.newProxyInstance(ConnectionDriver.class.getClassLoader(),new Class<?>[]{ Connection.class},new ConnectionHandler());

}

}2.数据连接池类（重要）。 我用过的有Pop3数据库连接池。
import java.sql.Connection;
import java.util.LinkedList;

public class MyDatabaseConnectPool {

private static final int DEFAULT_SIZE=20;

private static final int MINSIZE=1;

private static final int MAXSIZE=100;

//数据链接队列
private LinkedList<Connection> connectionList=new LinkedList<>();

//无参数构造
public MyDatabaseConnectPool() {

for(int i=0;i<DEFAULT_SIZE;++i){
connectionList.add(ConnectionDriver.createConnection());
}
}

//初始化连接池
public MyDatabaseConnectPool(int initialSize) {

if(initialSize>0){

initialSize=initialSize<MINSIZE? MINSIZE:initialSize;
initialSize=initialSize>MAXSIZE ? MAXSIZE:initialSize;

for(int i=0;i<initialSize;++i){
connectionList.add(ConnectionDriver.createConnection());
}

}else{
throw new Error("initialSize must >0");
}
}

public void releaseConnection(Connection connection){

if(connection!=null){

synchronized (connectionList){
//将空闲链接放入队列
connectionList.addLast(connection);

//通知其他等待的线程 有可用的链
connectionList.notifyAll();
}
}

}

//获取链接函数
public Connection getConnection(long mills) throws InterruptedException {

//获取队列的锁
synchronized (connectionList){

if(mills<=0){

while (connectionList.isEmpty()){

try {
connectionList.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

return connectionList.removeFirst();

}else{

//进行超时等待获取链接

long futrer_time=System.currentTimeMillis()+mills;

long remain_time=mills;

while (remain_time>0 && connectionList.isEmpty()){

connectionList.wait(remain_time);

//先等待后再获取剩余时间
remain_time=futrer_time-System.currentTimeMillis();
}

Connection connection=null;

//如果此时队列不为空,获取链接
if(!connectionList.isEmpty()){
connection=connectionList.removeFirst();
}

return connection;
}

}

}

}

分析：此处的队列使用LinkedList ，是为了使用链表增删节点性能较好。还可以使用下面的方法：
 connectionList.addLast(connection);   
 connectionList.removeFirst();
3.测试类：
import java.sql.Connection;
import java.sql.SQLException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class Test {

static MyDatabaseConnectPool pool = null;

//设定两个闭关锁 一个用于开启线程活动 一个用于监控所有线程的工作完成状态
static CountDownLatch start = new CountDownLatch(1);

static CountDownLatch end;

public static void main(String[] args) {

System.out.println("我们开始运行！！！！");

pool=new MyDatabaseConnectPool(-5);
int thread_count=10;
int count=20;

end=new CountDownLatch(thread_count);
AtomicInteger success_count=new AtomicInteger(0);
AtomicInteger faile_count=new AtomicInteger(0);

//开启多个线程
for(int i=0;i<thread_count;++i){
new MyConnectUser(count,success_count,faile_count).start();
}

//发出 可以获取链接 的命令
start.countDown();

try {
//此处锁住 等待所有线程完成工作
end.await();
} catch (InterruptedException e) {
e.printStackTrace();
}

//打印各个指标

System.out.println("The total try times :"+thread_count*count);
System.out.println("The total success times: "+success_count);
System.out.println("The totla faile times :"+faile_count);

}

private static class MyConnectUser extends Thread {

//线程内获取次数
int count;

//分别用来统计 成功/失败 获取次数
AtomicInteger success_count;
AtomicInteger faile_cout;

public MyConnectUser(int count, AtomicInteger success_count, AtomicInteger faile_cout) {

this.count = count;
this.success_count = success_count;
this.faile_cout = faile_cout;

}

@Override
public void run() {

try {
start.await();
} catch (InterruptedException e) {
e.printStackTrace();
}

while (count>0){

try {
//尝试获取链接
Connection connection= pool.getConnection(50);

if(connection!=null) {

try {
//模拟真实使用链接
connection.createStatement();
connection.commit();
} catch (SQLException e) {
e.printStackTrace();
}finally {
//成功次数加1
success_count.incrementAndGet();
//释放链接
pool.releaseConnection(connection);
}

}else{
//失败次数加1
faile_cout.incrementAndGet();
}

} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//线程内尝试获取次数减一
count--;

}
}
//告诉end 我这个线程的工作完成
end.countDown();
}
}

}总结：这只是我对数据库连接池的理解和简单实现，真是的数据库连接池肯定是要复杂的多。如果有出错的地方请各位在评论处指出。