池化技术简介

在我们使用数据库的过程中，我们往往使用数据库连接池而不是直接使用数据库连接进行操作，这是因为每一个数据库连接的创建和销毁的代价是昂贵的，而池化技术则预先创建了资源，这些资源是可复用的,这样就保证了在多用户情况下只能使用指定数目的资源，避免了一个用户创建一个连接资源，造成程序运行开销过大。关于Java并发编程的总结和思考

连接池实现原理

这里只实现一个简易的连接池，更多复杂的需求可根据该连接池进行改进，该连接池主要参数如下：

1. 一个繁忙队列busy
2. 一个空闲队列idle
3. 连接池最大活动连接数maxActive
4. 连接池最大等待时间maxWait
5. 连接池的活动连接数activeSize

程序流程图如下：

代码实现

泛型接口ConnectionPool.java

public interface ConnectionPool<T> {

/**

* 初始化池资源

* @param maxActive 池中最大活动连接数

* @param maxWait 最大等待时间

*/

void init(Integer maxActive, Long maxWait);

/**

* 从池中获取资源

* @return 连接资源

*/

T getResource() throws Exception;

/**

* 释放连接

* @param connection 正在使用的连接

*/

void release(T connection) throws Exception;

/**

* 释放连接池资源

*/

void close();

}

以zookeeper为例，实现zookeeper连接池，ZookeeperConnectionPool.java

public class ZookeeperConnectionPool implements ConnectionPool<ZooKeeper> {

//最大活动连接数

private Integer maxActive;

//最大等待时间

private Long maxWait;

//空闲队列

private LinkedBlockingQueue<ZooKeeper> idle = new LinkedBlockingQueue<>();

//繁忙队列

private LinkedBlockingQueue<ZooKeeper> busy = new LinkedBlockingQueue<>();

//连接池活动连接数

private AtomicInteger activeSize = new AtomicInteger(0);

//连接池关闭标记

private AtomicBoolean isClosed = new AtomicBoolean(false);

//总共获取的连接记数

private AtomicInteger createCount = new AtomicInteger(0);

//等待zookeeper客户端创建完成的计数器

private static ThreadLocal<CountDownLatch> latchThreadLocal = ThreadLocal.withInitial(() -> new CountDownLatch(1));

public ZookeeperConnectionPool(Integer maxActive, Long maxWait) {

this.init(maxActive, maxWait);

}

@Override

public void init(Integer maxActive, Long maxWait) {

this.maxActive = maxActive;

this.maxWait = maxWait;

}

@Override

public ZooKeeper getResource() throws Exception {

ZooKeeper zooKeeper;

Long nowTime = System.currentTimeMillis();

final CountDownLatch countDownLatch = latchThreadLocal.get();

//空闲队列idle是否有连接

if ((zooKeeper = idle.poll()) == null) {

//判断池中连接数是否小于maxActive

if (activeSize.get() < maxActive) {

//先增加池中连接数后判断是否小于等于maxActive

if (activeSize.incrementAndGet() <= maxActive) {

//创建zookeeper连接

zooKeeper = new ZooKeeper("localhost", 5000, (watch) -> {

if (watch.getState() == Watcher.Event.KeeperState.SyncConnected) {

countDownLatch.countDown();

}

});

countDownLatch.await();

System.out.println("Thread:" + Thread.currentThread().getId() + "获取连接：" + createCount.incrementAndGet() + "条");

busy.offer(zooKeeper);

return zooKeeper;

} else {

//如增加后发现大于maxActive则减去增加的

activeSize.decrementAndGet();

}

}

//若活动线程已满则等待busy队列释放连接

try {

System.out.println("Thread:" + Thread.currentThread().getId() + "等待获取空闲资源");

Long waitTime = maxWait - (System.currentTimeMillis() - nowTime);

zooKeeper = idle.poll(waitTime, TimeUnit.MILLISECONDS);

} catch (InterruptedException e) {

throw new Exception("等待异常");

}

//判断是否超时

if (zooKeeper != null) {

System.out.println("Thread:" + Thread.currentThread().getId() + "获取连接：" + createCount.incrementAndGet() + "条");

busy.offer(zooKeeper);

return zooKeeper;

} else {

System.out.println("Thread:" + Thread.currentThread().getId() + "获取连接超时，请重试！");

throw new Exception("Thread:" + Thread.currentThread().getId() + "获取连接超时，请重试！");

}

}

//空闲队列有连接，直接返回

busy.offer(zooKeeper);

return zooKeeper;

}

@Override

public void release(ZooKeeper connection) throws Exception {

if (connection == null) {

System.out.println("connection 为空");

return;

}

if (busy.remove(connection)){

idle.offer(connection);

} else {

activeSize.decrementAndGet();

throw new Exception("释放失败");

}

}

@Override

public void close() {

if (isClosed.compareAndSet(false, true)) {

idle.forEach((zooKeeper) -> {

try {

zooKeeper.close();

} catch (InterruptedException e) {

e.printStackTrace();

}

});

busy.forEach((zooKeeper) -> {

try {

zooKeeper.close();

} catch (InterruptedException e) {

e.printStackTrace();

}

});

}

}

}

测试用例

这里创建20个线程并发测试连接池，Test.java

public class Test {

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

int threadCount = 20;

Integer maxActive = 10;

Long maxWait = 10000L;

ZookeeperConnectionPool pool = new ZookeeperConnectionPool(maxActive, maxWait);

CountDownLatch countDownLatch = new CountDownLatch(20);

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

new Thread(() -> {

countDownLatch.countDown();

try {

countDownLatch.await();

ZooKeeper zooKeeper = pool.getResource();

Thread.sleep(2000);

pool.release(zooKeeper);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

}

}).start();

}

while (true){

}

}

}