java数据库链接池实现原理

时间 2019-11-10

标签 java 数据库链接实现原理栏目 Java 繁體版

原文原文链接

1、为何在链接数据库时要使用链接池

数据库链接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤其突出。一个数据库链接对象均对应一个物理数据库链接，每次操做都打开一个物理链接，使用完都关闭链接，这样形成系统的性能低下。数据库链接池的解决方案是在应用程序启动时创建足够的数据库链接，并讲这些链接组成一个链接池(简单说：在一个“池”里放了好多半成品的数据库联接对象)，由应用程序动态地对池中的链接进行申请、使用和释放。对于多于链接池中链接数的并发请求，应该在请求队列中排队等待。而且应用程序能够根据池中链接的使用率，动态增长或减小池中的链接数。链接池技术尽量多地重用了消耗内存地资源，大大节省了内存，提升了服务器地服务效率，可以支持更多的客户服务。经过使用链接池，将大大提升程序运行效率，同时，咱们能够经过其自身的管理机制来监视数据库链接的数量、使用状况等。 java

2、数据库链接池的基本原理

数据库链接池的基本思想就是为数据库链接创建一个“缓冲池”。预先在缓冲池中放入必定数量的链接，当须要创建数据库链接时，只需从“缓冲池”中取出一个，使用完毕以后再放回去。咱们能够经过设定链接池最大链接数来防止系统无尽的与数据库链接。更为重要的是咱们能够经过链接池的管理机制监视数据库的链接的数量?使用状况，为系统开发?测试及性能调整提供依据。sql

3、数据库链接池的工做原理

链接池的工做原理主要由三部分组成，分别为链接池的创建、链接池中链接的使用管理、链接池的关闭。数据库

第1、链接池的创建。通常在系统初始化时，链接池会根据系统配置创建，并在池中建立了几个链接对象，以便使用时能从链接池中获取。链接池中的链接不能随意建立和关闭，这样避免了链接随意创建和关闭形成的系统开销。Java中提供了不少容器类能够方便的构建链接池，例如Vector、Stack等。服务器

第2、链接池的管理。链接池管理策略是链接池机制的核心，链接池内链接的分配和释放对系统的性能有很大的影响。其管理策略是：多线程

当客户请求数据库链接时，首先查看链接池中是否有空闲链接，若是存在空闲链接，则将链接分配给客户使用；若是没有空闲链接，则查看当前所开的链接数是否已经达到最大链接数，若是没达到就从新建立一个链接给请求的客户；若是达到就按设定的最大等待时间进行等待，若是超出最大等待时间，则抛出异常给客户。并发

当客户释放数据库链接时，先判断该链接的引用次数是否超过了规定值，若是超过就从链接池中删除该链接，不然保留为其余客户服务。app

该策略保证了数据库链接的有效复用，避免频繁的创建、释放链接所带来的系统资源开销。函数

第3、链接池的关闭。当应用程序退出时，关闭链接池中全部的链接，释放链接池相关的资源，该过程正好与建立相反。sqlserver

4、链接池关键问题分析

　　一、并发问题性能

　　为了使链接管理服务具备最大的通用性，必须考虑多线程环境，即并发问题。这个问题相对比较好解决，由于Java语言自身提供了对并发管理的支持，使用synchronized关键字便可确保线程是同步的。使用方法为直接在类方法前面加上synchronized关键字，如：

　　public synchronized Connection getConnection()

　　二、多数据库服务器和多用户

　　对于大型的企业级应用，经常须要同时链接不一样的数据库(如链接Oracle和Sybase)。如何链接不一样的数据库呢?咱们采用的策略是：设计一个符合单例模式的链接池管理类，在链接池管理类的惟一实例被建立时读取一个资源文件，其中资源文件中存放着多个数据库的url地址()?用户名()?密码()等信息。如 tx.url=172.21.15.123：5000/tx_it，tx.user=yang，tx.password=yang321。根据资源文件提供的信息，建立多个链接池类的实例，每个实例都是一个特定数据库的链接池。链接池管理类实例为每一个链接池实例取一个名字，经过不一样的名字来管理不一样的连接池。

　　对于同一个数据库有多个用户使用不一样的名称和密码访问的状况，也能够经过资源文件处理，即在资源文件中设置多个具备相同url地址，但具备不一样用户名和密码的数据库链接信息。

　　三、事务处理

　　咱们知道，事务具备原子性，此时要求对数据库的操做符合“ALL-ALL-NOTHING”原则,即对于一组SQL语句要么全作，要么全不作。

　　在Java语言中，Connection类自己提供了对事务的支持，能够经过设置Connection的AutoCommit属性为 false,而后显式的调用commit或rollback方法来实现。但要高效的进行Connection复用，就必须提供相应的事务支持机制。可采用每个事务独占一个链接来实现，这种方法能够大大下降事务管理的复杂性。

　　四、链接池的分配与释放

　　链接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，能够提升链接的复用度，从而下降创建新链接的开销，同时还能够加快用户的访问速度。

　　对于链接的管理可以使用空闲池。即把已经建立但还没有分配出去的链接按建立时间存放到一个空闲池中。每当用户请求一个链接时，系统首先检查空闲池内有没有空闲链接。若是有就把创建时间最长(经过容器的顺序存放实现)的那个链接分配给他(实际是先作链接是否有效的判断，若是可用就分配给用户，如不可用就把这个链接从空闲池删掉，从新检测空闲池是否还有链接);若是没有则检查当前所开链接池是否达到链接池所容许的最大链接数(maxConn),若是没有达到，就新建一个链接，若是已经达到，就等待必定的时间(timeout)。若是在等待的时间内有链接被释放出来就能够把这个链接分配给等待的用户，若是等待时间超过预约时间timeout,则返回空值(null)。系统对已经分配出去正在使用的链接只作计数，当使用完后再返还给空闲池。对于空闲链接的状态，可开辟专门的线程定时检测，这样会花费必定的系统开销，但能够保证较快的响应速度。也可采起不开辟专门线程，只是在分配前检测的方法。

　　五、链接池的配置与维护

　　链接池中到底应该放置多少链接，才能使系统的性能最佳?系统可采起设置最小链接数(minConn)和最大链接数(maxConn)来控制链接池中的链接。最小链接数是系统启动时链接池所建立的链接数。若是建立过多，则系统启动就慢，但建立后系统的响应速度会很快;若是建立过少，则系统启动的很快，响应起来却慢。这样，能够在开发时，设置较小的最小链接数，开发起来会快，而在系统实际使用时设置较大的，由于这样对访问客户来讲速度会快些。最大连接数是链接池中容许链接的最大数目，具体设置多少，要看系统的访问量，可经过反复测试，找到最佳点。

　　如何确保链接池中的最小链接数呢?有动态和静态两种策略。动态即每隔必定时间就对链接池进行检测，若是发现链接数量小于最小链接数，则补充相应数量的新链接,以保证链接池的正常运转。静态是发现空闲链接不够时再去检查。

5、链接池实现代码（java）

[java] view plain copy

package book.util;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.Date;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Vector;
public class Pool {
public static void main(String[] args) {
Pool pool = new Pool("com.microsoft.sqlserver.jdbc.SQLServerDriver","jdbc:sqlserver://localhost:1433;DataBaseName=Book","sa","aaaaaa");
try {
pool.createConnections(4);
} catch (SQLException e) {
e.printStackTrace();
}
Connection conn = pool.getConnection();
try {
String sql = "select * from allbook";
PreparedStatement ps;
ps = conn.prepareStatement(sql);
ResultSet rs=ps.executeQuery();
while(rs.next()){
System.out.println(rs.getString("BOOKNAME"));
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
pool.returnConnection(conn);
}
//long startTime=System.currentTimeMillis();
//long endTime=System.currentTimeMillis();
//System.out.println("程序运行时间： "+(endTime-startTime)+"ms");
}
private String jdbcDriver = "";//数据库驱动
private String dbUrl = "";//数据库url
private String dbUsername = "";//数据库用户名
private String dbPassword = "";//数据库密码
private String testTable = "";
private int initialConnectionsNum = 10;//链接池初始链接数
private int maxConnectionsNum = 50;//链接池最大链接数
private int incrementalConnections = 5;//每次动态添加的链接数
private Vector<PooledConnection> connections = null;//向量，存放链接池中的链接，初始为空
/*无参构造函数*/
public Pool()
{}
/*带参数的构造函数
* 初始化数据库驱动、数据库url、数据库用户名、数据库密码、测试表
* */
public Pool(String driver, String url, String name, String pass)
{
this.jdbcDriver = driver;
this.dbUrl = url;
this.dbUsername = name;
this.dbPassword = pass;
//this.testTable = table;
try {
this.createPool();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/*函数，建立链接池*/
public synchronized void createPool()
throws InstantiationException, IllegalAccessException,
ClassNotFoundException, SQLException
{
/*确保链接池为建立，若是已经建立，则保存链接的向量不为空
* */
if (this.connections != null)
{
return ;
}
//驱动器实例化
Driver driver = (Driver)(Class.forName(this.jdbcDriver).newInstance());
//注册驱动器
DriverManager.registerDriver(driver);
//建立保存链接的向量
this.connections = new Vector<PooledConnection>();
//建立数据库链接
this.createConnections(this.initialConnectionsNum);
}
/*函数，建立数据库链接
* */
private void createConnections (int num) throws SQLException
{
/*循环建立链接
* 须要首先检查当前链接数是否已经超出链接池最大链接数
* */
for (int i = 0; i < num; ++i)
{
//检查
if (this.connections.size() >= this.maxConnectionsNum)
{
return;
}
//建立链接
this.connections.addElement
(new PooledConnection(newConnection()));
}
}
/*函数,建立一个数据库链接*/
private Connection newConnection() throws SQLException
{
/*建立链接*/
Connection con = DriverManager.getConnection(this.dbUrl,
this.dbUsername, this.dbPassword);
/*若是是第一次建立链接，则检查所链接的数据库的容许最大链接数是否小于
* 咱们所设定的最大链接数*/
if (this.connections.size() == 0)
{
DatabaseMetaData metadata = con.getMetaData();
//获得数据库最大链接数
int dbMaxConnectionsNum = metadata.getMaxConnections();
//若是数据库最大链接数更小，则更改咱们所设定的链接池最大链接数
if (dbMaxConnectionsNum > 0
&& this.maxConnectionsNum > dbMaxConnectionsNum)
{
this.maxConnectionsNum = dbMaxConnectionsNum;
}
}
return con;
}
/*函数，获得一个可用链接
* */
public synchronized Connection getConnection ()
{
Connection con = null;
/*检查链接池是否已经创建*/
if (this.connections == null)
{
return con;
}
//获得一个可用链接
try {
con = this.getFreeConnection();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//若是未找到合适链接，循环等待、查找，知道找到合适链接
while(con == null)
{
this.wait(30);
try {
con = this.getFreeConnection();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return con;
}
/*函数，获得一个可用链接*/
private Connection getFreeConnection() throws SQLException
{
Connection con = null;
//查找一个可用链接
con = this.findFreeConnection();
//若是未找到可用链接，就创建一些新的链接，再次查找
if (con == null)
{
this.createConnections(this.incrementalConnections);
//再次查找
con = this.findFreeConnection();
}
return con;
}
/*函数，从现有链接中查找一个可用链接
* 在现有的链接中（向量connections中）找到一个空闲链接，
* 并测试这个连接是否可用，若不可用则从新创建链接，替换原来的链接*/
private Connection findFreeConnection () throws SQLException
{
Connection con = null;
for (int i = 0; i < this.connections.size(); ++i)
{
PooledConnection pol = (PooledConnection)this.connections.get(i);
if (!pol.isBusy())
{
/*若是此连接未被使用，则返回这个链接并，设置正在使用标志*/
con = pol.getCon();
pol.setBusy(true);
/*测试链接是否可用*/
if (!this.testCon(con))
{
con = this.newConnection();
pol.setCon(con);
}
break;
}
}
return con;
}
/*函数，测试链接是否可用
* */
private boolean testCon (Connection con)
{
boolean useable = true;
try
{
Statement st = con.createStatement();
ResultSet rs = st.executeQuery("select count(*) from " + this.testTable);
rs.next();
}
catch(SQLException e)
{
/*上面抛出异常，链接不可用，关闭*/
useable = false;
this.closeConnection(con);
}
return useable;
}
/*函数，将使用完毕的链接放回链接池中
* */
public void returnConnection(Connection con)
{
/*确保链接池存在*/
if (this.connections == null)
{
return ;
}
for (int i = 0; i < this.connections.size(); ++i)
{
PooledConnection pool = this.connections.get(i);
//找到相应链接，设置正在使用标志为false
if (con == pool.getCon())
{
pool.setBusy(false);
}
}
}
/*函数，刷新链接池中的链接*/
public synchronized void refreshConneciontPool () throws SQLException
{
/*确保链接池存在*/
if (this.connections == null)
{
return ;
}
for (int i = 0; i < this.connections.size(); ++i)
{
PooledConnection pool = this.connections.get(i);
if (pool.isBusy())
{
this.wait(5000);
}
this.closeConnection(pool.getCon());
pool.setCon(this.newConnection());
pool.setBusy(false);
}
}
/*函数，关闭链接池*/
public void closeConnectionPool()
{
/*确保链接池存在*/
if (this.connections == null)
{
return ;
}
for (int i = 0; i < this.connections.size(); ++i)
{
PooledConnection pool = this.connections.get(i);
if (pool.isBusy())
{
this.wait(5000);
}
this.closeConnection(pool.getCon());
this.connections.remove(i);
}
this.connections = null;
}
/*函数，暂时无可用链接，进入等待队列等待m秒，再试
* */
private void wait(int mSecond)
{
try {
Thread.sleep(mSecond);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @return the jdbcDriver
*/
public String getJdbcDriver() {
return jdbcDriver;
}
/**
* @param jdbcDriver the jdbcDriver to set
*/
public void setJdbcDriver(String jdbcDriver) {
this.jdbcDriver = jdbcDriver;
}
/**
* @return the dbUrl
*/
public String getDbUrl() {
return dbUrl;
}
/**
* @param dbUrl the dbUrl to set
*/
public void setDbUrl(String dbUrl) {
this.dbUrl = dbUrl;
}
/**
* @return the dbUsername
*/
public String getDbUsername() {
return dbUsername;
}
/**
* @param dbUsername the dbUsername to set
*/
public void setDbUsername(String dbUsername) {
this.dbUsername = dbUsername;
}
/**
* @return the dbPassword
*/
public String getDbPassword() {
return dbPassword;
}
/**
* @param dbPassword the dbPassword to set
*/
public void setDbPassword(String dbPassword) {
this.dbPassword = dbPassword;
}
/**
* @return the testTable
*/
public String getTestTable() {
return testTable;
}
/**
* @param testTable the testTable to set
*/
public void setTestTable(String testTable) {
this.testTable = testTable;
}
/**
* @return the initialConnectionsNum
*/
public int getInitialConnectionsNum() {
return initialConnectionsNum;
}
/**
* @param initialConnectionsNum the initialConnectionsNum to set
*/
public void setInitialConnectionsNum(int initialConnectionsNum) {
this.initialConnectionsNum = initialConnectionsNum;
}
/**
* @return the maxConnectionsNum
*/
public int getMaxConnectionsNum() {
return maxConnectionsNum;
}
/**
* @param maxConnectionsNum the maxConnectionsNum to set
*/
public void setMaxConnectionsNum(int maxConnectionsNum) {
this.maxConnectionsNum = maxConnectionsNum;
}
/**
* @return the incrementalConnections
*/
public int getIncrementalConnections() {
return incrementalConnections;
}
/**
* @param incrementalConnections the incrementalConnections to set
*/
public void setIncrementalConnections(int incrementalConnections) {
this.incrementalConnections = incrementalConnections;
}
/**
* @return the connections
*/
public Vector<PooledConnection> getConnections() {
return connections;
}
/**
* @param connections the connections to set
*/
public void setConnections(Vector<PooledConnection> connections) {
this.connections = connections;
}
/*函数，链接使用完毕，关闭链接*/
private void closeConnection (Connection con)
{
try
{
con.close();
}
catch(SQLException e)
{
e.printStackTrace();
}
}
/*内部使用的保存数据库链接的类
* 两个成员变量：链接、是否正在使用*/
class PooledConnection
{
private Connection con = null;//链接
private boolean busy = false;//是否正在使用，默认为非
/*构造函数*/
public PooledConnection(Connection con)
{
this.con = con;
}
/**
* @return the con
*/
public Connection getCon() {
return con;
}
/**
* @param con the con to set
*/
public void setCon(Connection con) {
this.con = con;
}
/**
* @return the busy
*/
public boolean isBusy() {
return busy;
}
/**
* @param busy the busy to set
*/
public void setBusy(boolean busy) {
this.busy = busy;
}
}
}