基本原理
在内部对象池中，维护一定数量的数据库连接，并对外暴露数据库连接的获取和返回方法。
如外部使用者可通过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();
}
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
