肥宅兜

导航

数据库连接池的原理

一.早期我们怎么进行数据库操作

       1.原理:一般来说,java应用程序访问数据库的过程是:

   ①装载数据库驱动程序;

   ②通过jdbc建立数据库连接;

   ③访问数据库,执行sql语句;

   ④断开数据库连接。

       2.代码 

       // 查询所有用户

 

[java] view plain copy
 
 print?
  1. Public void FindAllUsers(){  
  2.        //1、装载sqlserver驱动对象  
  3.        DriverManager.registerDriver(new SQLServerDriver());               
  4.        //2、通过JDBC建立数据库连接  
  5.        Connection con =DriverManager.getConnection("jdbc:sqlserver://192.168.2.6:1433;DatabaseName=customer", "sa", "123");              
  6.        //3、创建状态  
  7.        Statement state =con.createStatement();             
  8.        //4、查询数据库并返回结果  
  9.        ResultSet result =state.executeQuery("select * from users");             
  10.        //5、输出查询结果  
  11.        while(result.next()){  
  12.               System.out.println(result.getString("email"));  
  13.        }              
  14.        //6、断开数据库连接  
  15.        result.close();  
  16.        state.close();  
  17.        con.close();  
  18.  }  

 

3.分析

       程序开发过程中,存在很多问题:首先,每一次web请求都要建立一次数据库连接。建立连接是一个费时的活动,每次都得花费0.05s~1s的时间,而且系统还要分配内存资源。这个时间对于一次或几次数据库操作,或许感觉不出系统有多大的开销。可是对于现在的web应用,尤其是大型电子商务网站,同时有几百人甚至几千人在线是很正常的事。在这种情况下,频繁的进行数据库连接操作势必占用很多的系统资源,网站的响应速度必定下降,严重的甚至会造成服务器的崩溃。不是危言耸听,这就是制约某些电子商务网站发展的技术瓶颈问题。其次,对于每一次数据库连接,使用完后都得断开。否则,如果程序出现异常而未能关闭,将会导致数据库系统中的内存泄漏,最终将不得不重启数据库。还有,这种开发不能控制被创建的连接对象数,系统资源会被毫无顾及的分配出去,如连接过多,也可能导致内存泄漏,服务器崩溃。

       上述的用户查询案例,如果同时有1000人访问,就会不断的有数据库连接、断开操作:

 

 

       通过上面的分析,我们可以看出来,“数据库连接”是一种稀缺的资源,为了保障网站的正常使用,应该对其进行妥善管理。其实我们查询完数据库后,如果不关闭连接,而是暂时存放起来,当别人使用时,把这个连接给他们使用。就避免了一次建立数据库连接和断开的操作时间消耗。原理如下:

二. 技术演进出来的数据库连接池

       由上面的分析可以看出,问题的根源就在于对数据库连接资源的低效管理。我们知道,对于共享资源,有一个很著名的设计模式:资源池(resource pool)。该模式正是为了解决资源的频繁分配﹑释放所造成的问题。为解决上述问题,可以采用数据库连接池技术。数据库连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接,当需要建立数据库连接时,只需从“缓冲池”中取出一个,使用完毕之后再放回去。我们可以通过设定连接池最大连接数来防止系统无尽的与数据库连接。更为重要的是我们可以通过连接池的管理机制监视数据库的连接的数量﹑使用情况,为系统开发﹑测试及性能调整提供依据。

       我们自己尝试开发一个连接池,来为上面的查询业务提供数据库连接服务:

       ①   编写class 实现DataSource 接口

       ②   在class构造器一次性创建10个连接,将连接保存LinkedList中

       ③   实现getConnection  从 LinkedList中返回一个连接

       ④   提供将连接放回连接池中方法

 

       1、连接池代码       

[java] view plain copy
 
 print?
  1. public class MyDataSource implements DataSource {  
  2.           //链表 --- 实现栈结构  
  3.           privateLinkedList<Connection> dataSources = new LinkedList<Connection>();  
  4.   
  5.           //初始化连接数量  
  6.           publicMyDataSource() {  
  7.                  //一次性创建10个连接  
  8.                  for(int i = 0; i < 10; i++) {  
  9.                         try {  
  10.                            //1、装载sqlserver驱动对象  
  11.                            DriverManager.registerDriver(new SQLServerDriver());  
  12.                            //2、通过JDBC建立数据库连接  
  13.                            Connection con =DriverManager.getConnection(  
  14.                               "jdbc:sqlserver://192.168.2.6:1433;DatabaseName=customer", "sa", "123");  
  15.                            //3、将连接加入连接池中  
  16.                            dataSources.add(con);  
  17.                         } catch (Exception e) {  
  18.                            e.printStackTrace();  
  19.                         }  
  20.                  }  
  21.           }  
  22.   
  23.           @Override  
  24.           publicConnection getConnection() throws SQLException {  
  25.                  //取出连接池中一个连接  
  26.                  finalConnection conn = dataSources.removeFirst(); // 删除第一个连接返回  
  27.                  returnconn;  
  28.           }  
  29.   
  30.           //将连接放回连接池  
  31.           publicvoid releaseConnection(Connection conn) {  
  32.                  dataSources.add(conn);  
  33.                  }  
  34.    }  

 

       2、使用连接池重构我们的用户查询函数       

[java] view plain copy
 
 print?
  1. //查询所有用户  
  2. Public void FindAllUsers(){  
  3.        //1、使用连接池建立数据库连接  
  4.        MyDataSource dataSource = new MyDataSource();  
  5.        Connection conn =dataSource.getConnection();          
  6.        //2、创建状态  
  7.        Statement state =con.createStatement();             
  8.        //3、查询数据库并返回结果  
  9.        ResultSet result =state.executeQuery("select * from users");             
  10.        //4、输出查询结果  
  11.        while(result.next()){  
  12.               System.out.println(result.getString("email"));  
  13.        }              
  14.        //5、断开数据库连接  
  15.        result.close();  
  16.        state.close();  
  17.        //6、归还数据库连接给连接池  
  18.        dataSource.releaseConnection(conn);  
  19.  }  

 

 

       这就是数据库连接池的原理,它大大提供了数据库连接的利用率,减小了内存吞吐的开销。我们在开发过程中,就不需要再关心数据库连接的问题,自然有数据库连接池帮助我们处理,这回放心了吧。但连接池需要考虑的问题不仅仅如此,下面我们就看看还有哪些问题需要考虑。

三.连接池还要考虑更多的问题

       1、并发问题

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

      publicsynchronized connection getconnection()

 

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

       对于大型的企业级应用,常常需要同时连接不同的数据库(如连接oracle和sybase)。如何连接不同的数据库呢?我们采用的策略是:设计一个符合单例模式的连接池管理类,在连接池管理类的唯一实例被创建时读取一个资源文件,其中资源文件中存放着多个数据库的url地址等信息。根据资源文件提供的信息,创建多个连接池类的实例,每一个实例都是一个特定数据库的连接池。连接池管理类实例为每个连接池实例取一个名字,通过不同的名字来管理不同的连接池。

       对于同一个数据库有多个用户使用不同的名称和密码访问的情况,也可以通过资源文件处理,即在资源文件中设置多个具有相同url地址,但具有不同用户名和密码的数据库连接信息。

 

       3、事务处理

       我们知道,事务具有原子性,此时要求对数据库的操作符合“all-all-nothing”原则即对于一组sql语句要么全做,要么全不做。

       在java语言中,connection类本身提供了对事务的支持,可以通过设置connection的autocommit属性为false 然后显式的调用commit或rollback方法来实现。但要高效的进行connection复用,就必须提供相应的事务支持机制。可采用每一个事务独占一个连接来实现,这种方法可以大大降低事务管理的复杂性。

 

       4、连接池的分配与释放

       连接池的分配与释放,对系统的性能有很大的影响。合理的分配与释放,可以提高连接的复用度,从而降低建立新连接的开销,同时还可以加快用户的访问速度。

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

 

       5、连接池的配置与维护

       连接池中到底应该放置多少连接,才能使系统的性能最佳?系统可采取设置最小连接数(minconn)和最大连接数(maxconn)来控制连接池中的连接。最小连接数是系统启动时连接池所创建的连接数。如果创建过多,则系统启动就慢,但创建后系统的响应速度会很快;如果创建过少,则系统启动的很快,响应起来却慢。这样,可以在开发时,设置较小的最小连接数,开发起来会快,而在系统实际使用时设置较大的,因为这样对访问客户来说速度会快些。最大连接数是连接池中允许连接的最大数目,具体设置多少,要看系统的访问量,可通过反复测试,找到最佳点。

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

四.实际开发中有成熟的开源连接池供我们使用

       理解了连接池的原理就可以了,没有必要什么都从头写一遍,那样会花费很多时间,并且性能及稳定性也不一定满足要求。事实上,已经存在很多流行的性能优良的第三方数据库连接池jar包供我们使用。如:

       1.Apache commons-dbcp 连接池

        下载:http://commons.apache.org/proper/commons-dbcp/

 

       2.c3p0 数据库连接池

        下载:http://sourceforge.net/projects/c3p0/

 

  • c3p0是什么

  c3p0的出现,是为了大大提高应用程序和数据库之间访问效率的。

  它的特性:

  1. 编码的简单易用
  2. 连接的复用
  3. 连接的管理

  说到c3p0,不得不说一下jdbc本身,c3p0愿意就是对数据库连接的管理,那么原有的概念还是得清晰:DriverManager、Connection、StateMent、ResultMent。

  jdbc:java database connective这套API,不用多说,是一套用于连接各式dbms或连接桥接器的api,两个层级:上层供应用方调用api,下层,定义了各个dbms的spi的api(具体文档见:这里)。

  主要要提的是:datasource、DriverManager,想到哪儿写到哪儿,datasource是更高级一点的api,原因在于相对对应用来说更透明。

  Connection:同dbms的逻辑链接,类似于session管理概念, SQL statements are executed and results are returned within the context of a connection.

  jdbc的概念就到这里,平时用得比较多。

  • c3P0的概念

 

  c3p0的bean配置如下:

 1 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
 2         <property name="driverClass" value="${jdbc.driverClassName}" />
 3         <property name="jdbcUrl" value="${jdbc.url}" />
 4         <property name="user" value="${jdbc.username}" />
 5         <property name="password" value="${jdbc.password}" />
 6         <property name="checkoutTimeout" value="30000" />
 7         <property name="maxPoolSize" value="15" />
 8         <property name="idleConnectionTestPeriod" value="180" />
 9         <property name="maxIdleTime" value="180" />
10     </bean>

还有一些配置选项,后续详细说明。可见c3p0的bean引用使用的是:ComboPooledDataSource,该类结构如下:

 

 

以上类图都不是很完全,不过大体能表达出类之间的原理:

1、bean:ComboPooledDataSource的父类:AbstractPoolBackedDataSource有一个poolmanager字段,存储着对pool管理器

2、获取ds.getConnection()链接对象时,内部使用getPoolManger()获取C3p0ConnectionPooledManager(mgr)对象,该manager管理着pool对象:C3P0PooledConnectionPool对象,mgr.getPool().checkoutPooledConnection()

3、自此该connection已经被获取到了

4、让我们看看该connection的真实面目吧:

 ProxyConnection。

5、因此其实原理是:

  从pool里获取到的connection,是proxy包装的connection,而对connection的释放或者重用,是pool的管理责任:初始化池大小,维护池的大小(expand或shrink),管理unused、expired、checkout、checkin连接。

真正底层的连接是jdbc自己的连接,而c3p0的管理部分,基本上使用的是synchronized关键字,使用timerTask定时器工作。

 

配置介绍:

<c3p0-config> 
<default-config> 
<!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 --> 
<property name="acquireIncrement">3</property> 

<!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 --> 
<property name="acquireRetryAttempts">30</property> 

<!--两次连接中间隔时间,单位毫秒。Default: 1000 --> 
<property name="acquireRetryDelay">1000</property> 

<!--连接关闭时默认将所有未提交的操作回滚。Default: false --> 
<property name="autoCommitOnClose">false</property> 

<!--c3p0将建一张名为Test的空表,并使用其自带的查询语句进行测试。如果定义了这个参数那么 
属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作,它将只供c3p0测试 
使用。Default: null--> 
<property name="automaticTestTable">Test</property> 

<!--获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效 
保留,并在下次调用getConnection()的时候继续尝试获取连接。如果设为true,那么在尝试 
获取连接失败后该数据源将申明已断开并永久关闭。Default: false--> 
<property name="breakAfterAcquireFailure">false</property> 

<!--当连接池用完时客户端调用getConnection()后等待获取新连接的时间,超时后将抛出 
SQLException,如设为0则无限期等待。单位毫秒。Default: 0 --> 
<property name="checkoutTimeout">100</property> 

<!--通过实现ConnectionTester或QueryConnectionTester的类来测试连接。类名需制定全路径。 
Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester--> 
<property name="connectionTesterClassName"></property> 

<!--指定c3p0 libraries的路径,如果(通常都是这样)在本地即可获得那么无需设置,默认null即可 
Default: null--> 
<property name="factoryClassLocation">null</property> 

<!--Strongly disrecommended. Setting this to true may lead to subtle and bizarre bugs. 
(文档原文)作者强烈建议不使用的一个属性--> 
<property name="forceIgnoreUnresolvedTransactions">false</property> 

<!--每60秒检查所有连接池中的空闲连接。Default: 0 --> 
<property name="idleConnectionTestPeriod">60</property> 

<!--初始化时获取三个连接,取值应在minPoolSize与maxPoolSize之间。Default: 3 --> 
<property name="initialPoolSize">3</property> 

<!--最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 --> 
<property name="maxIdleTime">60</property> 

<!--连接池中保留的最大连接数。Default: 15 --> 
<property name="maxPoolSize">15</property> 

<!--JDBC的标准参数,用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements 
属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。 
如果maxStatements与maxStatementsPerConnection均为0,则缓存被关闭。Default: 0--> 
<property name="maxStatements">100</property> 

<!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0 --> 
<property name="maxStatementsPerConnection"></property> 

<!--c3p0是异步操作的,缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能 
通过多线程实现多个操作同时被执行。Default: 3--> 
<property name="numHelperThreads">3</property> 

<!--当用户调用getConnection()时使root用户成为去获取连接的用户。主要用于连接池连接非c3p0 
的数据源时。Default: null--> 
<property name="overrideDefaultUser">root</property> 

<!--与overrideDefaultUser参数对应使用的一个参数。Default: null--> 
<property name="overrideDefaultPassword">password</property> 

<!--密码。Default: null--> 
<property name="password"></property> 

<!--定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。注意: 
测试的表必须在初始数据源的时候就存在。Default: null--> 
<property name="preferredTestQuery">select id from test where id=1</property> 

<!--用户修改系统配置参数执行前最多等待300秒。Default: 300 --> 
<property name="propertyCycle">300</property> 

<!--因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的 
时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable 
等方法来提升连接测试的性能。Default: false --> 
<property name="testConnectionOnCheckout">false</property> 

<!--如果设为true那么在取得连接的同时将校验连接的有效性。Default: false --> 
<property name="testConnectionOnCheckin">true</property> 

<!--用户名。Default: null--> 
<property name="user">root</property> 

在Hibernate(spring管理)中的配置:
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
  <property name="driverClass"><value>oracle.jdbc.driver.OracleDriver</value></property>
  <property name="jdbcUrl"><value>jdbc:oracle:thin:@localhost:1521:Test</value></property>
  <property name="user"><value>Kay</value></property>
  <property name="password"><value>root</value></property>
  <!--连接池中保留的最小连接数。-->            
    <property name="minPoolSize" value="10" />        
    <!--连接池中保留的最大连接数。Default: 15 -->         
    <property name="maxPoolSize" value="100" />        
    <!--最大空闲时间,1800秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->               
    <property name="maxIdleTime" value="1800" />        
    <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->               
    <property name="acquireIncrement" value="3" />         
    <property name="maxStatements" value="1000" />          
    <property name="initialPoolSize" value="10" />          
    <!--每60秒检查所有连接池中的空闲连接。Default: 0 -->       
    <property name="idleConnectionTestPeriod" value="60" />          
    <!--定义在从数据库获取新连接失败后重复尝试的次数。Default: 30 -->       
    <property name="acquireRetryAttempts" value="30" />          
    <property name="breakAfterAcquireFailure" value="true" />              
    <property name="testConnectionOnCheckout" value="false" /> 
 </bean>

 

出处:http://blog.csdn.net/shuaihj/article/details/14223015

posted on 2016-07-26 20:34  肥宅兜  阅读(4611)  评论(0编辑  收藏  举报