数据库连接池示例以及性能分析

直接上代码:

连接池ConnectionPool:

package com.shuaicenglou.ConnectionPool;

import java.util.LinkedList;

public class ConnectionPool {
private LinkedList<Connection> pool = new LinkedList<>();
public ConnectionPool(int ininum){
if(ininum>0){
for(int i=0;i<ininum;i++) pool.addLast(new Connection(Integer.toString(i+1)));
}
}
public void relese(Connection connection){
if(connection!=null){
synchronized (pool) {
pool.addLast(connection);
pool.notifyAll();
}
}
}
public Connection getConnection(long millis){
synchronized (pool) {
if(!pool.isEmpty()){
return pool.removeLast();
}else{
long future = System.currentTimeMillis()+millis;
long remaning = millis;
while(pool.isEmpty()&&remaning>0){
try {
pool.wait(remaning);
remaning = future - System.currentTimeMillis();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Connection result = null;
if(!pool.isEmpty()) result = pool.removeLast();
return result;
}
}
}
}
在超时等待那里，也就是代码的27-34行，我原本是直接使用pool.wait(remaning);没有像<<Java并发编程的艺术>>上面那样使用future-remaining的写法，这导致我的连接池超时等待时间莫名地比书上的短，此处为何使用future-remaining的写法会让连接等待时间长一些，我无法理解，但是我的实现与<<Java并发编程的艺术>>上的实现对比，我的实现在并发程度高的时候劣化不够平缓。
模拟的数据库Connection:其commit方法只是睡眠100毫秒：

package com.shuaicenglou.ConnectionPool;

import java.util.concurrent.TimeUnit;
import java.util.jar.Attributes.Name;

public class Connection {
private String name;
public Connection(String name){
this.name = name;
}
public void commit(){
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}


测试:

package com.shuaicenglou.ConnectionPool;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

public class Test {
static ConnectionPool pool = new ConnectionPool(10);
static CountDownLatch start = new CountDownLatch(1);
static CountDownLatch end;
public static void main(String[] args)throws Exception {
int threadCount = 20;
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 R(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:"+notGot);
}
static class R implements Runnable{
int count;
AtomicInteger got,notGot;
public R(int count,AtomicInteger got,AtomicInteger notGot) {
this.count = count;
this.got = got;
this.notGot = notGot;
}
@Override
public void run() {
try {
start.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int i=0;i<count;i++){
Connection c = pool.getConnection(1000);
if(c!=null){
c.commit();
got.incrementAndGet();
pool.relese(c);
}else notGot.incrementAndGet();
}
end.countDown();
}
}
}

结果: