线程运用---等待超时模式实现一个连接池

1.SqlConnectImpl  数据库的连接

public class SqlConnectImplimplements Connection {

/*拿一个数据库连接*/

public static final Connection fetchConnection() {

return new SqlConnectImpl();

}

}

2.DBPool   连接池的实现

/**

* 类说明：连接池的实现

*/

public class DBPool {

private static LinkedListpool =new LinkedList();

public DBPool(int initialSize) {

if (initialSize >0) {

for (int i =0; i < initialSize; i++) {

pool.addLast(SqlConnectImpl.fetchConnection());

}

}

}

//    释放连接

public void releaseConnection(Connection connection) {

if (connection !=null) {

synchronized (pool) {

pool.addLast(connection);

pool.notifyAll();

}

}

}

// 在mills内无法获取到连接，将会返回null

public Connection fetchConnection(long mills)throws InterruptedException {

//TODO

synchronized (pool) {

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 connection =null;

if (!pool.isEmpty()) {

connection =pool.removeFirst();

}

return connection;

}

}

}

}

3.DBPoolTest  最后测试运行

public class DBPoolTest {

static DBPoolpool  =new DBPool(10);

// 控制器:控制main线程将会等待所有Woker结束后才能继续执行

static CountDownLatchend;

public static void main(String[] args)throws Exception {

// 线程数量

int threadCount =50;

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 Worker(count, got, notGot), "worker_"+i);

thread.start();

}

end.await();// main线程在此处等待

System.out.println("总共尝试了: " + (threadCount * count));

System.out.println("拿到连接的次数：  " + got);

System.out.println("没能连接的次数： " + notGot);

}

static class Workerimplements Runnable {

int    count;

AtomicIntegergot;

AtomicIntegernotGot;

public Worker(int count, AtomicInteger got,

AtomicInteger notGot) {

this.count = count;

this.got = got;

this.notGot = notGot;

}

public void run() {

while (count >0) {

try {

// 从线程池中获取连接，如果1000ms内无法获取到，将会返回null

                    // 分别统计连接获取的数量got和未获取到的数量notGot

                    Connection connection =pool.fetchConnection(1000);

if (connection !=null) {

try {

connection.createStatement();

connection.commit();

}finally {

pool.releaseConnection(connection);

got.incrementAndGet();

}

}else {

notGot.incrementAndGet();

System.out.println(Thread.currentThread().getName()

+"等待超时!");

}

}catch (Exception ex) {

}finally {

count--;

}

}

end.countDown();

}

}

}

以上内容仅代表个人学习的见解，希望可以为大家提供一个学习参考