XDCPool-数据库连接池框架

package com.sql.pool; import java.io.IOException; import java.sql.Connection; import java.sql.SQLException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import com.sql.handler.Deploy; import com.sql.handler.VectorConnection; import com.sql.handler.util.LogFactory; public class FixedConnectionPool extends AbstractConnectionPool{ /*线程安全数组*/ private static volatile VectorConnection<Connection> pool = new VectorConnection<>(); private static volatile VectorConnection<Connection> recordPool = new VectorConnection<>(); private static volatile VectorConnection<Connection> recordNewPool = new VectorConnection<>(); private static volatile Connection selectConnection; /*连接池中储存的最大数量*/ private static int POOL_SIZE; /*当线程池耗尽时，最大新建数量*/ private static int NEW_POOL_SIZE; /*信号量*/ private static Semaphore semp = null; /*检查机制的循环间隔时间*/ private final static int MS_TIME = 60; /*不同于synchronized的另一种锁机制*/ private final static Lock SELECT_LOCK = new ReentrantLock(); private final static Lock RELEASE_LOCK = new ReentrantLock(); private final static Lock CONNECTION_LOCK = new ReentrantLock(); /*定时器*/ private static ScheduledExecutorService scheduledExecutorService; /*构造方法，不做任何工作*/ private FixedConnectionPool() {} /** * 做初始化工作 * @throws InterruptedException */ private synchronized static void init() throws ClassNotFoundException, SQLException{ Logs.d("正在初始化连接池.."); semp = new Semaphore(NEW_POOL_SIZE); selectConnection = load(); for (int i = 0; i < POOL_SIZE; i++) { try { padCachePool(); } catch (InterruptedException e) {} } Logs.d("初始化完毕"); } /** * 得到select使用的连接，查询不同于其他三项，查询可以并发进行执行， * 所以我们只需提供一个连接来供所有用户使用 */ private static Connection getSelectConnection() throws SQLException, InterruptedException, ClassNotFoundException{ return isOkConnection(selectConnection) ? selectConnection : loadSelectConnection(); } /** * 加载查询使用的连接 * @return * @throws InterruptedException * @throws SQLException * @throws ClassNotFoundException */ private static Connection loadSelectConnection() throws InterruptedException, SQLException, ClassNotFoundException{ if(SELECT_LOCK.tryLock(8L,TimeUnit.SECONDS)){ loadSelectConnctionHandler(); SELECT_LOCK.unlock(); } Logs.d("成功拿到连接"); return selectConnection; } /** * 加载查询连接的处理方法 * @throws ClassNotFoundException * @throws SQLException */ private static void loadSelectConnctionHandler() throws ClassNotFoundException, SQLException{ if(selectConnection == null || selectConnection.isClosed()){ selectConnection = load(); } } /** * 返回连接到连接池 * 在这里进行控制，如果连接池里的连接数大于我们规定的数量，则对此连接进行关闭 */ private static void release(Connection con) throws SQLException, InterruptedException { if(!isOkConnection(con)){ return; } if(pool.contains(con)){ return; } releaseHandler(con); } /** * 处理回收连接的方法 * @param con * @throws InterruptedException * @throws SQLException */ private static void releaseHandler(Connection con) throws InterruptedException, SQLException{ if(pool.size() >= POOL_SIZE){ con.close(); return; } if(RELEASE_LOCK.tryLock(8L,TimeUnit.SECONDS)){ if(pool.size() < POOL_SIZE){ Logs.d("成功回收连接"); pool.add(con); RELEASE_LOCK.unlock(); } else{ con.close(); RELEASE_LOCK.unlock(); } } } /** * 新建连接 * @return * @throws SQLException * @throws ClassNotFoundException */ private static Connection getNewConnection() throws SQLException, ClassNotFoundException{ return newConnectionHandler(); } /** * 建立新连接的处理方法 * @return * @throws SQLException * @throws ClassNotFoundException */ private static Connection newConnectionHandler() throws SQLException, ClassNotFoundException{ if (recordNewPool.size() < NEW_POOL_SIZE){ Connection conn = load(); if(isOkConnection(conn)){ recordNewPool.add(conn); Logs.d("成功拿到新建的连接"); return conn; } } return null; } /** 返回连接池中的一个数据库连接 * 如果连接池中已经耗尽了Connextion * 则创建新的使用 */ private static Connection getConnection() throws ClassNotFoundException, InterruptedException, SQLException { Connection conn = getCacheConnection(); if(isOkConnection(conn)){ return conn; } do{ conn = getConnectionHandler(); }while(!isOkConnection(conn)); return conn; } /** * 控制新建连接的数目 * 通过信号量 * @return * @throws InterruptedException * @throws ClassNotFoundException * @throws SQLException */ private static Connection controlNewConnection() throws InterruptedException, ClassNotFoundException, SQLException{ Connection conn; if (recordNewPool.size() < NEW_POOL_SIZE) { semp.acquire(); if(isMaximum(semp)){ conn = getNewConnection(); semp.release(); return conn; } semp.release(); } return getWaitConnection(); } /** * 补充连接池 * @throws InterruptedException * @throws SQLException * @throws ClassNotFoundException */ private static synchronized void padCachePool() throws InterruptedException, ClassNotFoundException, SQLException{ while((recordPool.size() + pool.size()) < POOL_SIZE){ pool.add(load()); } } /** * 得到连接的处理方法 * @return * @throws InterruptedException * @throws SQLException * @throws ClassNotFoundException */ private static Connection getConnectionHandler() throws InterruptedException, SQLException, ClassNotFoundException{ Connection conn = controlNewConnection(); return isOkConnection(conn) ? conn : null; } private static Connection getCacheHandlerConnection() throws InterruptedException, SQLException{ Connection conn; if((recordPool.size() + pool.size()) > POOL_SIZE){ return null; } if(CONNECTION_LOCK.tryLock(8L,TimeUnit.SECONDS)){ while((recordPool.size() + pool.size())< POOL_SIZE){ conn = load(); if(isOkConnection(conn)){ recordPool.add(conn); CONNECTION_LOCK.unlock(); return conn; } } CONNECTION_LOCK.unlock(); } return null; } /** * 对新建连接通过信号量进行控制，这里提供判断条件 * @return */ private static boolean isMaximum(Semaphore semp){ final int i = recordNewPool.size(); final int j = semp.availablePermits(); final int z = NEW_POOL_SIZE - j; return (z + i) <= NEW_POOL_SIZE ? true : false; } /** * 得到缓存中的连接 * @return * @throws SQLException */ private static Connection getCacheConnection() throws SQLException{ while(pool.size() > 0){ Connection conn = getCacheConnectionHandler(); if (conn != null) { re