数据库连接池（手写简单实现）

基本原理

       在内部对象池中，维护一定数量的数据库连接，并对外暴露数据库连接的获取和返回方法。

       如外部使用者可通过getConnection方法获取数据库连接，使用完毕后再通过releaseConnection方法将连接返回，注意此时的连接并没有关闭，而是由连接池管理器回收，并为下一次使用做好准备。

连接池作用

①资源重用

      由于数据库连接得到重用，避免了频繁创建、释放连接引起的大量性能开销。在减少系统消耗的基础上，增进了系统环境的平稳性（减少内存碎片以级数据库临时进程、线程的数量）

②更快的系统响应速度

      数据库连接池在初始化过程中，往往已经创建了若干数据库连接置于池内备用。此时连接池的初始化操作均已完成。对于业务请求处理而言，直接利用现有可用连接，避免了数据库连接初始化和释放过程的时间开销，从而缩减了系统整体响应时间。

③新的资源分配手段

      对于多应用共享同一数据库的系统而言，可在应用层通过数据库连接的配置，实现数据库连接技术。

④统一的连接管理，避免数据库连接泄露

     在较为完备的数据库连接池实现中，可根据预先的连接占用超时设定，强制收回被占用的连接，从而避免了常规数据库连接操作中可能出现的资源泄露

手写实现数据库连接池

1、配置数据集相关配置（图方便，用javaBean存放信息）

//外部配置文件信息
public class DbBean {

	private String driverName = "com.mysql.jdbc.Driver";

	private String url = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC";

	private String userName = "root";

	private String password = "root";

	private String poolName = "DbBeanPool";// 连接池名字

	private int minConnections = 1; // 空闲池，最小连接数

	private int maxConnections = 10; // 空闲池，最大连接数

	private int initConnections = 5;// 初始化连接数

	private long waitTimeOut = 1000;// 重复获得连接的频率

	private int maxActiveConnections = 100;// 最大允许的连接数，和数据库对应

	private long connectionTimeOut = 1000 * 60 * 20;// 连接超时时间，默认20分钟

	public String getDriverName() {
		return driverName;
	}

	public void setDriverName(String driverName) {
		this.driverName = driverName;
	}

	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getPoolName() {
		return poolName;
	}

	public void setPoolName(String poolName) {
		this.poolName = poolName;
	}

	public int getMinConnections() {
		return minConnections;
	}

	public void setMinConnections(int minConnections) {
		this.minConnections = minConnections;
	}

	public int getMaxConnections() {
		return maxConnections;
	}

	public void setMaxConnections(int maxConnections) {
		this.maxConnections = maxConnections;
	}

	public int getInitConnections() {
		return initConnections;
	}

	public void setInitConnections(int initConnections) {
		this.initConnections = initConnections;
	}

	public long getConnTimeOut() {
		return waitTimeOut;
	}

	public void setConnTimeOut(long waitTimeOut) {
		this.waitTimeOut = waitTimeOut;
	}

	public int getMaxActiveConnections() {
		return maxActiveConnections;
	}

	public void setMaxActiveConnections(int maxActiveConnections) {
		this.maxActiveConnections = maxActiveConnections;
	}

	public long getConnectionTimeOut() {
		return connectionTimeOut;
	}

	public void setConnectionTimeOut(long connectionTimeOut) {
		this.connectionTimeOut = connectionTimeOut;
	}

}

2、实现数据库连接池

/**
 *数据库连接池
 * 1.初始化连接池
 *   根据初始化连接数，创建连接放到空闲池中
 * 2.创建获取连接getConnection方法
 *       判断是否小于最大活动连接数
 *       小于==》判断空闲连接池是否存有连接
 *           有==》直接取出放到活动连接池中，然后空闲连接池删除
 *           无==》创建新的连接，放到活动连接池中
 *        大于==》等待，重试
 */
public class ConnectionPool {
    // 使用线程安全的集合 空闲线程 容器 没有被使用的连接存放
    private List<Connection> freeConnection = new Vector<Connection>();
    // 使用线程安全的集合 活动线程 容器 容器正在使用的连接
    private List<Connection> activeConnection = new Vector<Connection>();
    private DbBean dbBean;

    private volatile int connNum = 0;

    //通过构造函数初始化连接池
    public ConnectionPool(DbBean dbBean){
        //获取配置文件信息
        this.dbBean = dbBean;
        //1.初始化连接池
        for(int i = 0;i < dbBean.getInitConnections();i++){
            Connection connection = newConnect();
            if(connection != null){
                //放到空闲连接池中
                freeConnection.add(connection);
            }
        }
    }

    /**
     * 2.创建获取连接getConnection方法
     *       判断是否小于最大活动连接数
     *       小于==》判断空闲连接池是否存有连接
     *           有==》直接取出放到活动连接池中，然后空闲连接池删除
     *           无==》创建新的连接，放到活动连接池中
     *        大于==》等待，重试
     * 3.释放连接 回收
     *      判断连接是否可用
     *          ==>判断空闲线程是否已满
     *              没满==》回收连接，放到空闲线程池中
     *              已满==》关闭连接
     *          活动连接池移除该连接
     */
    public synchronized Connection getConnection(){
        Connection connection = null;
        //判断是否小于最大活动连接数
        if(connNum <= dbBean.getMaxActiveConnections()){
            //判断空闲连接池是否存有连接
            if(freeConnection.size() > 0){
                //空闲连接池删除
                connection = freeConnection.remove(0);
            }else {
                //创建新的连接
                connection = newConnect();
            }
            //如果连接池可用
            if(isAvailable(connection)){
                //放到活动连接池中
                activeConnection.add(connection);
            }else {
                //连接已失效
                connNum--;
                //重复调用
                connection = getConnection();
            }
        }else {
            // 大于最大活动连接数，进行等待
            try {
                wait(dbBean.getConnTimeOut());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 重试
            connection = getConnection();
        }
        return connection;
    }

    //创建连接
    private synchronized Connection newConnect(){
        Connection connection = null;
        try {
            Class.forName(dbBean.getDriverName());
            connection = DriverManager.getConnection(dbBean.getUrl(), dbBean.getUserName(), dbBean.getPassword());
            //记录连接数
            connNum++;
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            return connection;
        }
    }

    // 判断连接是否可用
    public boolean isAvailable(Connection connection) {
        try {
            if (connection == null || connection.isClosed()) {
                return false;
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return true;
    }

    /**
     * 3.释放连接 回收
     *      判断连接是否可用
     *          ==>判断空闲线程是否已满
     *              没满==》回收连接，放到空闲线程池中
     *              已满==》关闭连接
     *          活动连接池移除该连接
     */
    public synchronized void releaseConnection(Connection connection){
        //判断连接是否可用
        if(isAvailable(connection)){
            //判断空闲线程是否已满
            if(freeConnection.size() < dbBean.getMaxConnections()){
                // 空闲线程没有满,回收连接
                freeConnection.add(connection);
            }else {
                // 空闲线程已经满
                try {
                    connection.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            //活动连接池移除该连接
            activeConnection.remove(connection);
            //连接数减一
            connNum--;
            notifyAll();
        }
    }
}

3、创建数据库连接池管理器，方便管理

//管理连接池
public class ConnectionPoolManager {
    private static DbBean dbBean = new DbBean();
    private static ConnectionPool connectionPool = new ConnectionPool(dbBean);

    // 获取连接(重复利用机制)
    public static Connection getConnection() {
        return connectionPool.getConnection();
    }

    // 释放连接(可回收机制)
    public static void releaseConnection(Connection connection) {
        connectionPool.releaseConnection(connection);
    }
}

4、测试

class ThreadConnection implements Runnable {
    public void run() {
        for (int i = 0; i < 10; i++) {
            Connection connection = ConnectionPoolManager.getConnection();
            System.out.println(Thread.currentThread().getName() + ",connection:" + connection);
            ConnectionPoolManager.releaseConnection(connection);
        }
    }

}
public class Test {
    public static void main(String[] args) {
        ThreadConnection threadConnection = new ThreadConnection();
        for (int i = 1; i < 3; i++) {
            Thread thread = new Thread(threadConnection, "线程i:" + i);
            thread.start();
        }
    }
}