hibernate事务处理

Hibernate是对JDBC的轻量级对象封装，Hibernate本身是不具备Transaction处理功能的，Hibernate的Transaction实际上是底层的JDBC Transaction的封装，或者是JTA Transaction的封装，下面我们详细的分析：

Hibernate可以配置为JDBCTransaction或者是JTATransaction，这取决于你在hibernate.properties中的配置:

#hibernate.transaction.factory_class

net.sf.hibernate.transaction.JTATransactionFactory

#hibernate.transaction.factory_class

net.sf.hibernate.transaction.JDBCTransactionFactory

如果你什么都不配置，默认情况下使用JDBCTransaction，如果你配置为：

hibernate.transaction.factory_class

net.sf.hibernate.transaction.JTATransactionFactory

将使用JTATransaction，不管你准备让Hibernate使用JDBCTransaction，还是JTATransaction，我的忠告就是什么都不配，将让它保持默认状态，如下：

一、JDBC Transaction

看看使用JDBC Transaction的时候我们的代码例子：

Session session = sf.openSession();

Transaction tx = session.beginTransactioin();

…

session.flush();

tx.commit();

session.close();

这是默认的情况，当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢？来看看源代码就清楚了：

Hibernate2.0.3源代码中的类

net.sf.hibernate.transaction.JDBCTransaction:

public void begin() throws HibernateException {

…

if (toggleAutoCommit) session.connection().setAutoCommit(false);

…

}

这是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗？是不是很熟悉？

再来看

public void commit() throws HibernateException {

…

try {

if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();

try {

session.connection().commit();

committed = true;

}

…

toggleAutoCommit();

}

这是提交方法，看到connection().commit() 了吗？下面就不用我多说了，这个类代码非常简单易懂，通过阅读使我们明白Hibernate的Transaction都在干了些什么？我现在把用Hibernate写的例子翻译成JDBC，大家就一目了然了：

AOP和Spring事务处理2008年05月01日星期四 00:40二. AOP

1. AOP是什么？

AOP是OOP的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

2. 切面意义何在？

就可以在这层切面上进行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需集中于自己领域内的逻辑实现。这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用性大大增强。

3. AOP应用范围

Authentication 权限

Caching 缓存

Context passing 内容传递

Error handling 错误处理

Lazy loading　懒加载

Debugging　　调试

logging, tracing, profiling and monitoring　记录跟踪　优化　校准

Performance optimization　性能优化

Persistence　　持久化

Resource pooling　资源池

Synchronization　同步

Transactions 事务

三.Spring事务处理

1.Spring事务管理能给我们带来什么?

对于传统的基于特定事务资源的事务处理而言（如基于JDBC 的数据库访问），Spring并不会对其产生什么影响，我们照样可以成功编写并运行这样的代码。同时，Spring还提供了一些辅助类可供我们选择使用，这些辅助类简化了传统的数据库操作流程，在一定程度上节省了工作量，提高了编码效率。

对于依赖容器的参数化事务管理而言，Spring则表现出了极大的价值。Spring本身也是一个容器，只是相对EJB容器而言，Spring显得更为轻便小巧。我们无需付出其他方面的代价，即可通过Spring实现基于容器的事务管理（本质上来讲，Spring的事务管理是基于动态AOP）。

2. Hibernate in Spring

applicationContext.xml

UserDAO.java ArticleDAO.java

public class UserDAOImpl extends HibernateDaoSupport implements UserDAO { public void saveUser(Tuser user) {

getHibernateTemplate().saveOrUpdate(user);

}

}

public class ArticleDAOImpl extends HibernateDaoSupport implements ArticleDAO {

public void saveArticle(Article article) {

getHibernateTemplate().saveOrUpdate(article);

}

}

HibernateDaoSupport

实现了HibernateTemplate和SessionFactory实例的关联。HibernateTemplate对Hibernate Session操作进行了封装，而HibernateTemplate.execute方法则是一封装机制的核心，感兴趣可以研究一下其实现机制。

借助HibernateTemplate我们可以脱离每次数据操作必须首先获得Session实例、启动事务、提交/回滚事务以及烦杂的try/catch/finally的繁琐操作。从而获得以上代码中精干集中的逻辑呈现效果。

org.mzone.service.impl.UserManagerImpl

public class UserManagerImpl implements UserManager {

private UserDAO userDao;

private ArticleDAO articleDao;

public void saveUserAndArticle(Tuser user, Article article) {

userDao.saveUser(user);

articleDao.saveArticle(article);

}

}

测试代码

InputStream is = new FileInputStream(“applicationContext.xml”);

XmlBeanFactory factory = new XmlBeanFactory(is);

UserManager userManager = (UserManager )factory.getBean(” baseTxProxy “);

user = new Tuser();

article = new Article();

user.setUsername(“hellboys_topic 1”);

user.setPassword(“12345678_topic 1”);

article.setTitle(“hellboys_topic 1”);

article.setContent(“hellboys_topic 1”);

userManager.saveUserAndArticle(user,article);

注意问题

UserManager userManager = (UserManager )factory.getBean(“baseTxProxy “);

UserManager userManager = (UserManagerImpl) ctx.getBean(“baseTxProxy”);

java.lang.ClassCastException

原因在于Spring的AOP实现机制，前面曾经提及，Spring中的事务管理实际上是基于动态AOP机制实现，为了实现动态AOP，Spring在默认情况下会使用Java DynamicProxy，但是，Dynamic Proxy要求其代理的对象必须实现一个接口，该接口定义了准备进行代理的方法。而对于没有实现任何接口的Java Class，需要采用其他方式，Spring通过CGLib10实现这一功能。

CGLib可以在运行期对Class行为进行修改。由于其功能强大，性能出众，常常被作为Java Dynamic Proxy之外的动态Proxy模式的实现基础。在Spring、Hibernate中都用到了CGLib类库。

类别：事务处理 | 添加到搜藏 | 浏览(27) | 评论 (0) 上一篇：hibernate事务处理下一篇：SQLSERVER事务处理

SQLSERVER事务处理2008年05月01日星期四 00:46事务定义：

事务是单个的工作单元。如果某一事务成功，则在该事务中进行的所有数据更改均会

提交，成为数据库中的永久组成部分。如果事务遇到错误且必须取消或回滚，则所有

数据更改均被清除。

事务三种运行模式：

自动提交事务

每条单独的语句都是一个事务。

显式事务

每个事务均以 BEGIN TRANSACTION 语句显式开始，

以 COMMIT 或 ROLLBACK 语句显式结束。

隐性事务

在前一个事务完成时新事务隐式启动，但每个事务仍以 COMMIT 或 ROLLBACK 语句

显式完成。

事务操作的语法：

BEGIN TRANSACTION

BEGIN DISTRIBUTED TRANSACTION

COMMIT TRANSACTION

COMMIT WORK

ROLLBACK WORK

SAVE TRANSACTION

BEGIN TRANSACTION

BEGIN TRANSACTION

标记一个显式本地事务的起始点。

BEGIN TRANSACTION将 @@TRANCOUNT 加 1。

BEGIN TRANSACTION 代表一点，由连接引用的数据在该点是逻辑和物理上都一致的。如果遇上错误，在 BEGIN TRANSACTION 之后的所有数据改动都能进行回滚，以将数据返回到已知的一致状态。每个事务继续执行直到它无误地完成并且用 COMMIT TRANSACTION 对数据库作永久的改动，或者遇上错误并且用 ROLLBACK TRANSACTION 语句擦除所有改动

语法

BEGIN TRAN [ SACTION ] [ transaction_name | @tran_name_variable [ WITH MARK [ ‘description’ ] ] ]

例子：

BEGIN TRAN T1

UPDATE table1 …

–nest transaction M2

BEGIN TRAN M2 WITH MARK

UPDATE table2 …

SELECT * from table1

COMMIT TRAN M2

UPDATE table3 …

COMMIT TRAN T1

BEGIN DISTRIBUTED TRANSACTION

指定一个由 Microsoft 分布式事务处理协调器 (MS DTC) 管理的 Transact-SQL 分布式事务的起始。

语法

BEGIN DISTRIBUTED TRAN [ SACTION ]

[ transaction_name | @tran_name_variable ]

参数

transaction_name

是用户定义的事务名，用于跟踪 MS DTC 实用工具中的分布式事务。 transaction_name 必须符合标识符规则，但是仅使用头 32 个字符

@tran_name_variable

是用户定义的一个变量名，它含有一个事务名，该事务名用于跟踪 MS DTC 实用工具中的分布式事务。必须用 char、varchar、nchar 或 nvarchar 数据类型声明该变量。

注释

执行BEGIN DISTRIBUTED TRANSACTION 语句的服务器是事务创建人，并且控制事务的完成

当连接发出后续 COMMIT TRANSACTION 或 ROLLBACK TRANSACTION 语句时，

主控服务器请求 MS DTC 在所涉及的服务器间管理分布式事务的完成。

有两个方法可将远程 SQL 服务器登记在一个分布式事务中：

分布式事务中已登记的连接执行一个远程存储过程调用，该调用引用一个远程服务器。

分布式事务中已登记的连接执行一个分布式查询，该查询引用一个远程服务器。

示例

本例在本地和远程数据库上更新作者的姓。本地和远程数据库将同时提交或同时回滚本事务。

说明

当前的SQL Server 上必须安装 MS DTC.

USE pubs

GO

BEGIN DISTRIBUTED TRANSACTION

UPDATE authors

SET au_lname = ‘McDonald’ WHERE au_id = ‘409-56-7008’

EXECUTE link_Server_T.pubs.dbo.changeauth_lname ‘409-56-7008′,’McDonald’

COMMIT TRAN

GONote:

如果需要连接远程DB,如果是linkServer 方式连接的话，一定要修该linkServer的 RPC 选项置为 True。

SET XACT_ABORT

指定当 Transact-SQL 语句产生运行时错误时，Microsoft? SQL Server? 是否自动回滚当前事务。

( 可以比较简单的理解，如果中间有任何一句SQL 出错，所有SQL全部回滚.特别适用于 Procedure 中间调用Procedure ，如果第一个Procedure Ok，被调用的Procedure 中间有错误，如果SET XACT_ABORT=false，则出错的部分回滚，其他部分提交，当然外部Procedure 也提交。）.

—在分布式Trans中一定要注意设置下面参数(XACT_ABORT)

语法SET XACT_ABORT { ON | OFF }

注释当 SET XACT_ABORT 为 ON 时，如果 Transact-SQL 语句产生运行时错误，整个事务将终止并回滚。为 OFF 时，只回滚产生错误的Transact-SQL 语句，而事务将继续进行处理。编译错误（如语法错误）不受 SET XACT_ABORT 的影响。

对于大多数 OLE DB 提供程序（包括 SQL Server），隐性或显式事务中的数据修改语句必须将 XACT_ABORT 设置为 ON。

SET XACT_ABORT 的设置是在执行或运行时设置，而不是在分析时设置。

示例下例导致在含有其它 Transact-SQL 语句的事务中发生违反外键错误。在第一个语句集中产生错误，但其它语句均成功执行且事务成功

提交。在第二个语句集中，SET XACT_ABORT 设置为 ON。这导致语句错误使批处理终止，并使事务回滚。

CREATE TABLE t1 (a int PRIMARY KEY)

CREATE TABLE t2 (a int REFERENCES t1(a))

GO

INSERT INTO t1 VALUES (1)

INSERT INTO t1 VALUES (3)

INSERT INTO t1 VALUES (4)

INSERT INTO t1 VALUES (6)

GO

SET XACT_ABORT OFF

GO

BEGIN TRAN

INSERT INTO t2 VALUES (1)

INSERT INTO t2 VALUES (2) /* Foreign key error */

INSERT INTO t2 VALUES (3)

COMMIT TRAN

GO

SET XACT_ABORT ON

GO

BEGIN TRAN

INSERT INTO t2 VALUES (4)

INSERT INTO t2 VALUES (5) /* Foreign key error */

INSERT INTO t2 VALUES (6)

COMMIT TRAN

GO

SAVE TRANSACTION

在事务内设置保存点。

语法 SAVE TRAN [ SACTION ] { savepoint_name | @savepoint_variable }

参数 savepoint_name

是指派给保存点的名称。保存点名称必须符合标识符规则，但只使用前 32 个字符。

@savepoint_variable

是用户定义的、含有有效保存点名称的变量的名称。

必须用 char、varchar、nchar 或 nvarchar 数据类型声明该变量。注释

用户可以在事务内设置保存点或标记。保存点定义如果有条件地取消事务的一部分，事务可以返回的位置。如果将事务回滚到保存点，则必须（如果需要，使用更多的 Transact-SQL 语句和 COMMIT TRANSACTION 语句）继续完成事务，或者必须（通过将事务回滚到其起始点）完全取消事务。若要取消整个事务，请使用 ROLLBACK TRANSACTION transaction_name 格式。这将撤消事务的所有语句和过程。

Note：1：在由 BEGIN DISTRIBUTED TRANSACTION 显式启动或从本地事务升级而来的分布式事务中，不支持 SAVE TRANSACTION。

2：当事务开始时，将一直控制事务中所使用的资源直到事务完成（也就是锁定）。当将事务的一部分回滚到保存点时，将继续控制资源直到事务完成（或者回滚全部事务）。

例子：begin transaction

save transaction A

insert into demo values(‘BB’,’B term’)

rollback TRANSACTION A

create table demo2(name varchar(10),age int)

insert into demo2(name,age) values(‘lis’,1)

commit transaction

ROLLBACK TRANSACTION

将显式事务或隐性事务回滚到事务的起点或事务内的某个保存点。

语法

ROLLBACK [ TRAN [ SACTION ]

[ transaction_name | @tran_name_variable | savepoint_name | @savepoint_variable ] ]

参数

transaction_name

是给 BEGIN TRANSACTION 上的事务指派的名称。transaction_name 必须符合标识符规则，但只使用事务名称的前 32 个字符。嵌套

事务时，transaction_name 必须是来自最远的 BEGIN TRANSACTION 语句的名称。

@tran_name_variable

是用户定义的、含有有效事务名称的变量的名称。必须用 char、varchar、nchar 或 nvarchar 数据类型声明该变量。

savepoint_name

是来自 SAVE TRANSACTION 语句的 savepoint_name。savepoint_name 必须符合标识符规则。当条件回滚只影响事务的一部分时使用 savepoint_name。

@savepoint_variable

是用户定义的、含有有效保存点名称的变量的名称。必须用 char、varchar、nchar 或 nvarchar 数据类型声明该变量。

注释 ROLLBACK TRANSACTION 清除自事务的起点或到某个保存点所做的所有数据修改。ROLLBACK 还释放由事务控制的资源。

不带 savepoint_name 和 transaction_name 的 ROLLBACK TRANSACTION 回滚到事务的起点。嵌套事务时，该语句将所有内层事务回滚到最远的 BEGIN TRANSACTION 语句。在这两种情况下，ROLLBACK TRANSACTION 均将 @@TRANCOUNT 系统函数减为 0。ROLLBACK

TRANSACTION savepoint_name 不减少 @@TRANCOUNT。

Note:

ROLLBACK TRANSACTION 语句若指定 savepoint_name 则不释放任何锁。

在由 BEGIN DISTRIBUTED TRANSACTION 显式启动或从本地事务升级而来的分布式事务中，ROLLBACK TRANSACTION 不能

引用savepoint_name。在执行 COMMIT TRANSACTION 语句后不能回滚事务。

在事务内允许有重复的保存点名称，但 ROLLBACK TRANSACTION 若使用重复的保存点名称，则只回滚到最近的使用该保存点名称的SAVE TRANSACTION。

在存储过程中，不带 savepoint_name 和 transaction_name 的 ROLLBACK TRANSACTION 语句将所有语句回滚到最远的 BEGINTRANSACTION。在存储过程中，ROLLBACK TRANSACTION 语句使 @@TRANCOUNT 在触发器完成时的值不同于调用该存储过程时的@@TRANCOUNT 值，并且生成一个信息。该信息不影响后面的处理。

如果在触发器中发出 ROLLBACK TRANSACTION：将回滚对当前事务中的那一点所做的所有数据修改，包括触发器所做的修改。

触发器继续执行 ROLLBACK 语句之后的所有其余语句。如果这些语句中的任意语句修改数据，则不回滚这些修改。执行其余的语句不会激发嵌套触发器。在批处理中，不执行所有位于激发触发器的语句之后的语句。每次进入触发器，@@TRANCOUNT 就增加 1，即使在自动提交模式下也是如此。（系统将触发器视作隐性嵌套事务。）

在存储过程中，ROLLBACK TRANSACTION 语句不影响调用该过程的批处理中的后续语句；

将执行批处理中的后续语句。在触发器中，ROLLBACK TRANSACTION 语句终止含有激发触发器的语句的批处理；

不执行批处理中的后续语句。

ROLLBACK TRANSACTION 语句不生成显示给用户的信息。如果在存储过程或触发器中需要警告，请使用 RAISERROR 或 PRINT 语句。RAISERROR 是用于指出错误的首选语句。

ROLLBACK 对游标的影响由下面三个规则定义：

当 CURSOR_CLOSE_ON_COMMIT 设置为 ON 时，ROLLBACK 关闭但不释放所有打开的游标。

当 CURSOR_CLOSE_ON_COMMIT 设置为 OFF 时，ROLLBACK 不影响任何打开的同步 STATIC 或 INSENSITIVE 游标不影响已完全填充的异步 STATIC 游标。将关闭但不释放任何其它类型的打开的游标。

对于导致终止批处理并生成内部回滚的错误，将释放在含有该错误语句的批处理内声明的所有游标。

不论游标的类型或 CURSOR_CLOSE_ON_COMMIT 的设置，所有游标均将被释放，其中包括在该错误批处理所调用的存储过程内声明的游标。在该错误批处理之前的批处理内声明的游标以规则 1 和 2 为准。死锁错误就属于这类错误。在触发器中发出的 ROLLBACK 语句也自动生成这类错误。

权限

ROLLBACK TRANSACTION 权限默认授予任何有效用户。

例子：

begin transaction

save transaction A

insert into demo values(‘BB’,’B term’)

rollback TRANSACTION A

— select * into demo2 from demo1

create table demo2(name varchar(10),age int)

insert into demo2(name,age) values(‘lis’,1)

rollback transaction

COMMIT TRANSACTION

标志一个成功的隐性事务或用户定义事务的结束。如果 @@TRANCOUNT 为 1，COMMIT

TRANSACTION 使得自从事务开始以来所执行的所有数据修改成为数据库的永久部分，释放连接

占用的资源，并将 @@TRANCOUNT 减少到 0。如果@@TRANCOUNT 大于 1，则COMMIT

TRANSACTION 使 @@TRANCOUNT 按 1 递减。

只有当事务所引用的所有数据的逻辑都正确时，发出 COMMIT TRANSACTION 命令。

COMMIT WORK

标志事务的结束。

语法

COMMIT [ WORK ]

注释

此语句的功能与 COMMIT TRANSACTION 相同，但 COMMIT TRANSACTION 接受用户定义的事务

名称。这个指定或没有指定可选关键字WORK 的 COMMIT 语法与 SQL-92 兼容

例子：

begin transaction a

insert into demo values(‘BB’,’B term’)

commit TRANSACTION A

隐性事务

当连接以隐性事务模式进行操作时，SQL Server将在提交或回滚当前事务后自动启动新事务。无须描述事务的开始，只需提交或

回滚每个事务。隐性事务模式生成连续的事务链。

在为连接将隐性事务模式设置为打开之后，当 SQL Server 首次执行下列任何语句时，都会自动启动一个事务：

ALTER TABLE

INSERT

CREATE

OPEN

DELETE

REVOKE

DROP

SELECT

FETCH

TRUNCATE TABLE

GRANT

UPDATE

在发出 COMMIT 或 ROLLBACK 语句之前，该事务将一直保持有效。在第一个事务被提交或回滚之后，下次当连接执行这些语句

中的任何语句时，SQL Server 都将自动启动一个新事务。SQL Server 将不断地生成一个隐性事务链，

直到隐性事务模式关闭为止

例子：

begin transaction

save transaction A

insert into demo values(‘BB’,’B term’)

rollback TRANSACTION A

create table demo2(name varchar(10),age int)

insert into demo2(name,age) values(‘lis’,1)

rollback transaction

— 在 Create table demo2 时 SQL Server 已经隐式创建一个Trans,知道提交或回滚

嵌套事务处理:

1： Trans 嵌套，将内部的trans 合并到外部并形成一个Trans.

begin tran t1

—-In the first trans .

Insert into demo2(name,age) values(‘lis’,1)

—Second Trans begin transaction t2

insert into demo values(‘BB’,’B term’)

commit transaction t2

—-In the first trans .

Insert into demo2(name,age) values(‘lis’,2)

rollback transaction t1

Note:

在一系列嵌套的事务中用一个事务名给多个事务命名对该事务没有什么影响。系统仅登记第一个（最外部的）事务名。回滚

到其它任何名字（有效的保存点名除外）都会产生错误。

事实上，任何在回滚之前执行的语句都没有在错误发生时回滚。这语句仅当外层的事务回滚时才会进行回滚。

例：内部事务回滚SQL server 报错。

begin tran t1

Insert into demo2(name,age) values(‘lis’,1)

—Second Trans

–Server: Msg 6401, Level 16, State 1, Line 6

—Cannot roll back t2. No transaction or savepoint of that name was found.

begin transaction t2

insert into demo values(‘BB’,’B term’)

rollback transaction t2

—-In the first trans .

Insert into demo2(name,age) values(‘lis’,2)

commit transaction t1

例：内部事务提交SQL server 不会报错。

begin tran t1

Insert into demo2(name,age) values(‘lis’,1)

—Second Trans no error

begin transaction t2

insert into demo values(‘BB’,’B term’)

commit transaction t2

—-In the first trans .

Insert into demo2(name,age) values(‘lis’,2)

commit transaction t1

SQL Server 的隔离级别：

1: 设置TimeOut 参数

Set Lock_TimeOut 5000

被锁超时5秒将自动解锁

Set Lock_TimeOut 0

产立即解锁，返回Error 默认为-1，无限等待

2：

(SET TRANSACTION ISOLATION LEVEL

{ READ COMMITTED

| READ UNCOMMITTED

| REPEATABLE READ | SERIALIZABLE}）

READ COMMITTED

指定在读取数据时控制共享锁以避免脏读，但数据可在事务结束前更改，从而产生不可重复读取或

幻像数据。该选项是SQL Server 的默认值。

避免脏读，并在其他session 在事务中不能对已有数据进行修改。共享锁。

READ UNCOMMITTED

执行脏读或 0 级隔离锁定，这表示不发出共享锁，也不接受排它锁。当设置该选项时，可以对数

据执行未提交读或脏读；在事务结束前可以更改数据内的数值，行也可以出现在数据集中或从数据

集消失。该选项的作用与在事务内所有语句中的所有表上设置 NOLOCK 相同。这是四个隔离级别中

限制最小的级别。

REPEATABLE READ

锁定查询中使用的所有数据以防止其他用户更新数据，但是其他用户可以将新的幻像行插入数据

集，且幻像行包括在当前事务的后续读取中。因为并发低于默认隔离级别，所以应只在必要时才使

用该选项。

SERIALIZABLE

在数据集上放置一个范围锁，以防止其他用户在事务完成之前更新数据集或将行插入数据集内。这

是四个隔离级别中限制最大的级别。因为并发级别较低，所以应只在必要时才使用该选项。该选项

的作用与在事务内所有 SELECT 语句中的所有表上设置 HOLDLOCK 相同。

类别：事务处理 | 添加到搜藏 | 浏览(181) | 评论 (0) 上一篇：AOP和Spring事务处理下一篇：SQL事务处理

SQL事务处理2008年05月01日星期四 00:49所谓事务是指一组逻辑操作单元，它使数据从一种状态变换到另一种状态。

包括四个特性:

1、原子性

就是事务应作为一个工作单元,事务处理完成，所有的工作要么都在数据库中保存下来，要么完全回滚，全部不保留

2、一致性

事务完成或者撤销后，都应该处于一致的状态

3、隔离性

多个事务同时进行，它们之间应该互不干扰.应该防止一个事务处理其他事务也要修改的数据时，

不合理的存取和不完整的读取数据

4、持久性

事务提交以后，所做的工作就被永久的保存下来

示例：创建一个存储过程,向两个表中同时插入数据

Create proc RegisterUser

(@usrName varchar(30), @usrPasswd varchar(30),@age int,@sex varchar(10), @PhoneNum varchar(20), @Address varchar(50) )

as begin

begin tran

insert into userinfo(userName,userPasswd) values(@usrName,@usrPasswd)

if @@error<>0

begin

rollback tran

return -1

end

insert into userdoc(userName,age,sex,PhoneNumber,Address)values(@Usrname,@age,@sex,@PhoneNum,@Address)

if @@error<>0

begin

rollback tran

return -1

end

commit tran

return 0

end

事务的分类

按事务的启动与执行方式，可以将事务分为3类:

显示事务

也称之为用户定义或用户指定的事务，即可以显式地定义启动和结束的事务。分布式事务属于显示事务

自动提交事务

默认事务管理模式。如果一个语句成功地完成，则提交该语句；如果遇到错误，则回滚该语句。

隐性事务

当连接以此模式进行操作时，sql将在提交或回滚当前事务后自动启动新事务。无须描述事务的开始，只需提交或回滚每个事务。它生成连续的事务链。

一、显示事务

通过begin transacton、commit transaction、commit work、rollback transaction或rollback work等语句完成。

1、启动事务

格式:begin tran 事务名或变量 with mark 描述

2、结束事务

格式:commit tran 事务名或变量 (事务名与begin tran中的事务名一致

或commit work 但此没有参数

3、回滚事务

rollback tran 事务名或变量 | savepoint_name | savepoint_variable

或rollback work

说明:清除自事务的起点或到某个保存点所做的所有数据修改

4、在事务内设置保存点

格式:save tran savepoint_name | savepoint_variable

示例:

use bookdb

go

begin tran mytran

insert into book

values(9,”windows2000′,1,22,’出版社’)

save tran mysave

delete book where book_id=9

rollback tran mysave

commit tran

go

select * from book

go

可以知道，上面的语句执行后，在book中插入了一笔记录，而并没有删除。因为使用rollback tran mysave 语句将操作回滚到了删除前的保存点处。

5、标记事务

格式:with mark

例：使用数据库标记将日志恢复到预定义时间点的语句

在事务日志中置入一个标记。请注意，被标记的事务至少须提交一个更新，以标记该日志。

BEGIN TRAN MyMark WITH MARK

UPDATE pubs.dbo.LastLogMark SET MarkTime = GETDATE()

COMMIT TRAN MyMark

按照您常用的方法备份事务日志。

BACKUP LOG pubs TO DISK=’C:/Backups/Fullbackup.bak’ WITH INIT

现在您可以将数据库恢复至日志标记点。首先恢复数据库，并使其为接受日志恢复做好准备。

RESTORE DATABASE pubs FROM DISK=N’C:/Backups/Fullbackup.bak’ WITH NORECOVERY

现在将日志恢复至包含该标记的时间点，并使其可供使用。请注意，STOPAT在数据库正在执行大容量日志时禁止执行。

RESTORE LOG pubs FROM DISK=N’C:/Backups/Logbackup.bak’ WITH RECOVERY,

STOPAT=’02/11/2002 17:35:00′

5、不能用于事务的操作

创建数据库 create database

修改数据库 alter database

删除数据库 drop database

恢复数据库 restore database

加载数据库 load database

备份日志文件 backup log

恢复日志文件 restore log

更新统计数据 update statitics

授权操作              grant

复制事务日志 dump tran

磁盘初始化           disk init

更新使用sp_configure后的系统配置           reconfigure

二、自动提交事务

sql连接在begin tran 语句启动显式事务，或隐性事务模式设置为打开之前，将以自动提交模式进行操作。当提交或回滚显式事务，或者关闭隐性事务模式时，将返回到自动提交模式。

示例:

由于编译错误，使得三个insert都没执行

use test

go

create table testback(cola int primary key ,colb char(3))

go

insert into testback values(1,’aaa’)

insert into testback values(2,’bbb’)

insert into testback value(3,’ccc’) /*符号错误*/

go

select * from testback

go

没有任何结果返回

三、隐式事务

通过 API 函数或 Transact-SQL SET IMPLICIT_TRANSACTIONS ON 语句，将隐性事务模式设置为打开。下一个语句自动启动一个新事务。当该事务完成时，再下一个 Transact-SQL 语句又将启动一个新事务。

当有大量的DDL 和DML命令执行时会自动开始，并一直保持到用户明确提交为止，切换隐式事务可以用SET IMPLICIT_TRANSACTIONS

为连接设置隐性事务模式.当设置为 ON 时，SET IMPLICIT_TRANSACTIONS 将连接设置为隐性事务模式。当设置为 OFF 时，则使连接返回到自动提交事务模式

语句包括:

alter table insert open create delete revoke drop

select fetch truncate table grant update

示例:

下面使用显式与隐式事务。它使用@@tracount函数演示打开的事务与关闭的事务:

use test

go

set nocount on

create table t1(a int)

go

insert into t1 values(1)

go

print ‘使用显式事务’

begin tran

insert into t1 values(2)

print ‘事务外的事务数目:’+cast(@@trancount as char(5))

commint tran

print ‘事务外的事务数目:’+cast(@@trancount as char(5))

go

print

go

set implicit_transactions on

go

print ‘使用隐式事务’

go

insert into t1 values*4)

print’事务内的事务数目:’+cast(@@trancount as char(5))

commint tran

print’事务外的事务数目:’+cast(@@trancount as char(5))

go

执行结果:

使用显示事务

事务内的事务数目:2

事务外的事务数目:1

使用隐式事务

事务内的事务数目:1

事务外的事务数目:0

四、分布式事务

跨越两个或多个数据库的单个sql server中的事务就是分布式事务。

与本地事务区别:必须由事务管理器管理，以尽量避免出现因网络故障而导致一个事务由某些资源管理器成功提交，但由另一些资源管理器回滚的情况。

sql server 可以由DTc microsoft distributed transaction coordinator 来支持处理分布式事务,可以使用 BEgin distributed transaction 命令启动一个分布式事务处理

分二阶段:

A 准备阶段

B 提交阶段

执行教程:

1、sql 脚本或应用程序连接执行启动分布式事务的sql语句

2、执行该语句的sql在为事务中的主控服务器

3、脚本或应用程序对链接的服务器执行分布式查询，或对远程服务器执行远程存储过程。

4、当执行了分布式查询或远程过程调用后，主控服务器将自动调用msdtc以便登记分布式事务中链接的服务器和远程服务器

5、当脚本或应用程序发出commit或rollback语句时，主控sql将调用msdtc管理两阶段提交过程，或者通知链接的服务器和远程服务器回滚其事务。

类别：事务处理 | 添加到搜藏 | 浏览(262) | 评论 (0) 上一篇：SQLSERVER事务处理下一篇：java多线程

java多线程2008年05月01日星期四 01:00线程间的通信

1.     线程的几种状态

线程有四种状态，任何一个线程肯定处于这四种状态中的一种：

1)     产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没对它调用start()函数之前。

2)      可执行（Runnable）：每个支持多线程的系统都有一个排程器，排程器会从线程池中选择一个线程并启动它。当一个线程处于可执行状态时，表示它可能正处于线程池中等待排排程器启动它；也可能它已正在执行。如执行了一个线程对象的start()方法后，线程就处于可执行状态，但显而易见的是此时线程不一定正在执行中。

3)     死亡（Dead）：当一个线程正常结束，它便处于死亡状态。如一个线程的run()函数执行完毕后线程就进入死亡状态。

4)      停滞（Blocked）：当一个线程处于停滞状态时，系统排程器就会忽略它，不对它进行排程。当处于停滞状态的线程重新回到可执行状态时，它有可能重新执行。如通过对一个线程调用wait()函数后，线程就进入停滞状态，只有当两次对该线程调用notify或notifyAll后它才能两次回到可执行状态。

2.     class　Thread下的常用函数函数

2.1     suspend()、resume()

1)     通过suspend()函数，可使线程进入停滞状态。通过suspend()使线程进入停滞状态后，除非收到resume()消息，否则该线程不会变回可执行状态。

2)     当调用suspend()函数后，线程不会释放它的“锁标志”。

例11：

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public synchronized void run(){

if(shareVar==0){

for(int i=0; i<5; i++){

shareVar++;

if(shareVar==5){

this.suspend();　//（1）

}

}

}

else{

System.out.print(Thread.currentThread().getName());

System.out.println(” shareVar = ” + shareVar);

this.resume();　//（2）

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.start();　//（5）

//t1.start();　//（3）

t2.start();　//（4）

}

}

运行结果为：

t2 shareVar = 5

i.     当代码（5）的t1所产生的线程运行到代码（1）处时，该线程进入停滞状态。然后排程器从线程池中唤起代码（4）的t2所产生的线程，此时shareVar值不为0，所以执行else中的语句。

ii.     也许你会问，那执行代码（2）后为什么不会使t1进入可执行状态呢？正如前面所说，t1和t2是两个不同对象的线程，而代码（1）和（2）都只对当前对象进行操作，所以t1所产生的线程执行代码（1）的结果是对象t1的当前线程进入停滞状态；而t2所产生的线程执行代码（2）的结果是把对象t2中的所有处于停滞状态的线程调回到可执行状态。

iii.     那现在把代码（4）注释掉，并去掉代码（3）的注释，是不是就能使t1重新回到可执行状态呢？运行结果是什么也不输出。为什么会这样呢？也许你会认为，当代码（5）所产生的线程执行到代码（1）时，它进入停滞状态；而代码（3）所产生的线程和代码（5）所产生的线程是属于同一个对象的，那么就当代码（3）所产生的线程执行到代码（2）时，就可使代码（5）所产生的线程执行回到可执行状态。但是要清楚，suspend()函数只是让当前线程进入停滞状态，但并不释放当前线程所获得的“锁标志”。所以当代码（5）所产生的线程进入停滞状态时，代码（3）所产生的线程仍不能启动，因为当前对象的“锁标志”仍被代码（5）所产生的线程占有。

2.2      sleep()

1)     sleep ()函数有一个参数，通过参数可使线程在指定的时间内进入停滞状态，当指定的时间过后，线程则自动进入可执行状态。

2)     当调用sleep ()函数后，线程不会释放它的“锁标志”。

例12：

class TestThreadMethod extends Thread{

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public synchronized void run(){

for(int i=0; i<3; i++){

System.out.print(Thread.currentThread().getName());

System.out.println(” : ” + i);

try{

Thread.sleep(100);　//（4）

}

catch(InterruptedException e){

System.out.println(“Interrupted”);

}

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.start();　（1）

t1.start();　（2）

//t2.start();　（3）

}

}

运行结果为：

t1 : 0

t1 : 1

t1 : 2

t1 : 0

t1 : 1

t1 : 2

由结果可证明，虽然在run()中执行了sleep()，但是它不会释放对象的“锁标志”，所以除非代码(1)的线程执行完run()函数并释放对象的“锁标志”，否则代码（2）的线程永远不会执行。

如果把代码（2）注释掉，并去掉代码（3）的注释，结果将变为：

t1 : 0

t2 : 0

t1 : 1

t2 : 1

t1 : 2

t2 : 2

由于t1和t2是两个对象的线程，所以当线程t1通过sleep()进入停滞时，排程器会从线程池中调用其它的可执行线程，从而t2线程被启动。

例13：

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public synchronized void run(){

for(int i=0; i<5; i++){

System.out.print(Thread.currentThread().getName());

System.out.println(” : ” + i);

try{

if(Thread.currentThread().getName().equals(“t1”))

Thread.sleep(200);

else

Thread.sleep(100);

}

catch(InterruptedException e){

System.out.println(“Interrupted”);

}

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.start();

//t1.start();

t2.start();

}

}

运行结果为：

t1 : 0

t2 : 0

t2 : 1

t1 : 1

t2 : 2

t2 : 3

t1 : 2

t2 : 4

t1 : 3

t1 : 4

由于线程t1调用了sleep(200)，而线程t2调用了sleep(100)，所以线程t2处于停滞状态的时间是线程t1的一半，从从结果反映出来的就是线程t2打印两倍次线程t1才打印一次。

2.3     yield()

1)     通过yield ()函数，可使线程进入可执行状态，排程器从可执行状态的线程中重新进行排程。所以调用了yield()的函数也有可能马上被执行。

2)     当调用yield ()函数后，线程不会释放它的“锁标志”。

例14：

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public synchronized void run(){

for(int i=0; i<4; i++){

System.out.print(Thread.currentThread().getName());

System.out.println(” : ” + i);

Thread.yield();

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.start();

t1.start();　//（1）

//t2.start();　（2）

}

}

运行结果为：

t1 : 0

t1 : 1

t1 : 2

t1 : 3

t1 : 0

t1 : 1

t1 : 2

t1 : 3

从结果可知调用yield()时并不会释放对象的“锁标志”。

如果把代码（1）注释掉，并去掉代码（2）的注释，结果为：

t1 : 0

t1 : 1

t2 : 0

t1 : 2

t2 : 1

t1 : 3

t2 : 2

t2 : 3

从结果可知，虽然t1线程调用了yield()，但它马上又被执行了。

2.4     sleep()和yield()的区别

1)     sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。

2)     sleep()可使优先级低的线程得到执行的机会，当然也可以让同优先级和高优先级的线程有执行的机会；yield()只能使同优先级的线程有执行的机会。

例15：

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public void run(){

for(int i=0; i<4; i++){

System.out.print(Thread.currentThread().getName());

System.out.println(” : ” + i);

//Thread.yield();　（1）

/* （2） */

try{

Thread.sleep(3000);

}

catch(InterruptedException e){

System.out.println(“Interrupted”);

}

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.setPriority(Thread.MAX_PRIORITY);

t2.setPriority(Thread.MIN_PRIORITY);

t1.start();

t2.start();

}

}

运行结果为：

t1 : 0

t1 : 1

t2 : 0

t1 : 2

t2 : 1

t1 : 3

t2 : 2

t2 : 3

由结果可见，通过sleep()可使优先级较低的线程有执行的机会。注释掉代码（2），并去掉代码（1）的注释，结果为：

t1 : 0

t1 : 1

t1 : 2

t1 : 3

t2 : 0

t2 : 1

t2 : 2

t2 : 3

可见，调用yield()，不同优先级的线程永远不会得到执行机会。

2.5 join()

使调用join()的线程执行完毕后才能执行其它线程，在一定意义上，它可以实现同步的功能。

例16：

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public void run(){

for(int i=0; i<4; i++){

System.out.println(” ” + i);

try{

Thread.sleep(3000);

}

catch(InterruptedException e){

System.out.println(“Interrupted”);

}

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

t1.start();

try{

t1.join();

}

catch(InterruptedException e){}

t1.start();

}

}

运行结果为：

0

1

2

3

0

1

2

3

3. class　Object下常用的线程函数

wait()、notify()和notifyAll()这三个函数由java.lang.Object类提供，用于协调多个线程对共享数据的存取。

3.1 wait()、notify()和notifyAll()

1) wait()函数有两种形式：第一种形式接受一个毫秒值，用于在指定时间长度内暂停线程，使线程进入停滞状态。第二种形式为不带参数，代表waite()在notify()或notifyAll()之前会持续停滞。

2) 当对一个对象执行notify()时，会从线程等待池中移走该任意一个线程，并把它放到锁标志等待池中；当对一个对象执行notifyAll()时，会从线程等待池中移走所有该对象的所有线程，并把它们放到锁标志等待池中。

3) 当调用wait()后，线程会释放掉它所占有的“锁标志”，从而使线程所在对象中的其它synchronized数据可被别的线程使用。

例17：

下面，我们将对例11中的例子进行修改

class TestThreadMethod extends Thread{

public static int shareVar = 0;

public TestThreadMethod(String name){

super(name);

}

public synchronized void run(){

if(shareVar==0){

for(int i=0; i<10; i++){

shareVar++;

if(shareVar==5){

try{

this.wait();　//（4）

}

catch(InterruptedException e){}

}

}

}

if(shareVar!=0){

System.out.print(Thread.currentThread().getName());

System.out.println(” shareVar = ” + shareVar);

this.notify();　//（5）

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

TestThreadMethod t2 = new TestThreadMethod(“t2”);

t1.start();　//（1）

//t1.start();　（2）

t2.start();　//（3）

}

}

运行结果为：

t2 shareVar = 5

因为t1和t2是两个不同对象，所以线程t2调用代码（5）不能唤起线程t1。如果去掉代码（2）的注释，并注释掉代码（3），结果为：

t1 shareVar = 5

t1 shareVar = 10

这是因为，当代码（1）的线程执行到代码（4）时，它进入停滞状态，并释放对象的锁状态。接着，代码（2）的线程执行run()，由于此时shareVar 值为5，所以执行打印语句并调用代码（5）使代码（1）的线程进入可执行状态，然后代码（2）的线程结束。当代码（1）的线程重新执行后，它接着执行 for()循环一直到shareVar=10，然后打印shareVar。

3.2 wait()、notify()和synchronized

waite ()和notify()因为会对对象的“锁标志”进行操作，所以它们必须在synchronized函数或synchronized　block中进行调用。如果在non-synchronized函数或non-synchronized　block中进行调用，虽然能编译通过，但在运行时会发生 IllegalMonitorStateException的异常。

例18：

class TestThreadMethod extends Thread{

public int shareVar = 0;

public TestThreadMethod(String name){

super(name);

new Notifier(this);

}

public synchronized void run(){

if(shareVar==0){

for(int i=0; i<5; i++){

shareVar++;

System.out.println(“i = ” + shareVar);

try{

System.out.println(“wait……”);

this.wait();

}

catch(InterruptedException e){}

}

}

}

}

class Notifier extends Thread{

private TestThreadMethod ttm;

Notifier(TestThreadMethod t){

ttm = t;

start();

}

public void run(){

while(true){

try{

sleep(2000);

}

catch(InterruptedException e){}

/*1 要同步的不是当前对象的做法 */

synchronized(ttm){

System.out.println(“notify……”);

ttm.notify();

}

}

}

}

public class TestThread{

public static void main(String[] args){

TestThreadMethod t1 = new TestThreadMethod(“t1”);

t1.start();

}

}

运行结果为：

i = 1

wait……

notify……

i = 2

wait……

notify……

i = 3

wait……

notify……

i = 4

wait……

notify……

i = 5

wait……

notify……

4. wait()、notify()、notifyAll()和suspend()、resume()、sleep()的讨论

4.1 这两组函数的区别

1) wait()使当前线程进入停滞状态时，还会释放当前线程所占有的“锁标志”，从而使线程对象中的synchronized资源可被对象中别的线程使用；而suspend()和sleep()使当前线程进入停滞状态时不会释放当前线程所占有的“锁标志”。

2) 前一组函数必须在synchronized函数或synchronized　block中调用，否则在运行时会产生错误；而后一组函数可以non-synchronized函数和synchronized　block中调用。

4.2 这两组函数的取舍

Java2已不建议使用后一组函数。因为在调用wait()时不会释放当前线程所取得的“锁标志”，这样很容易造成“死锁”。

类别：多线程 | 添加到搜藏 | 浏览(16) | 评论 (0) 上一篇：SQL事务处理下一篇：数据库连接池

数据库连接池2008年05月01日星期四 01:51f数据库连接池概述：

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用，连接池都将一直保证至少拥有这么多的连接数量。连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：

1) 最小连接数是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪费；

2) 最大连接数是连接池能申请的最大连接数，如果数据库连接请求超过此数，后面的数据库连接请求将被加入到等待队列中，这会影响之后的数据库操作。

3) 如果最小连接数与最大连接数相差太大，那么最先的连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放，它将被放到连接池中等待重复使用或是空闲超时后被释放。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是每次都重新建立一个，并通过释放空闲时间超过最大空闲时间的数据库连接，来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库的操作性能。

———————————————————————————————————————————–

数据库连接池在初始化时将创建一定数据的数据库连接放到连接池中，连接的数量由最小数据库连接数来设定。无论这些数据库连接是否被使用，连接池都将一直保证到少拥有这么多的连接数据，连接池的最大数据库连接数量限定了这个连接池能占有的的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中，直到有连接变空闲为止。

从连接池中得到的Connection并不是最原始的Java.sql.Connection，而是重新封装过的。它与原Connection最大的差别在于：调用close()方法时，并不是真正关闭连接，而是将其放入连接池以备再次使用。

所以，虽然数据库连接的真正关闭是由连接池来管理的，但是，在程序中，用完一个连接后依然要调用其close()方法，使其能够再次被使用，相反，如果使用完后忘记了调用close()方法，那么此连接将一直被占用而不能被其他用户使用，可想而知，如果每人得到一个连接过后都不释放，连接池的最大数很快就会达到，此后再不会有其他进程能够得到数据库连接，以至使整个应用程序瘫痪，由此可知，使用连接池时，数据库连接的释放是非常重要的。

———————————————————————————————————————————–

连接池允许应用程序从连接池中获得一个连接并使用这个连接，而不需要为每一个连接请求重新建立一个连接。一旦一个新的连接被创建并且放置在连接池中，应用程序就可以重复使用这个连接而不必实施整个数据库连接创建过程。

当应用程序请求一个连接时，连接池为该应用程序分配一个连接而不是重新建立一个连接；当应用程序使用完连接后，该连接被归还给连接池而不是直接释放。

当然，实现连接池时要注意：确保你每一次的连接使用相同的连接字符串（和连接池相同）；只有连接字符串相同时连接池才会工作。如果连接字符串不相同，应用程序就不会使用连接池而是创建一个新的连接。

何时创建连接池？

当第一个连接请求到来时创建连接池；连接池的建立由数据库连接的连接字符创来决定。每一个连接池都与一个不同的连接字符串相关。当一个新的连接请求到来时如果连接字符串和连接池使用的字符串相同，就从连接池取出一个连接；如果不相同，就新建一个连接池。

何时关闭连接池？

当连接池中的所有连接都已经关闭时关闭连接池。

数据库连接池，提供多个链接通道，当某一个连接请求到来的时候，分配一个通道即可，不用重新启动连接线程（或进程）

——————————————————————————————————————————-

实际执行过程：

1) 新建一个DBConnectionManager类的实例。

2) 然后调用DBConnectionManager. CreatePool()创建一个连接池，并把这个连接池加入到pools的HasthTable中。(这种过程可执行多次，对应不同的数据连接，可能是sql2k的，也可能是oracle的，但生成的DBConnectionPool都要放到pools中进行统一管理，用并用一个名字与相应的DBConnectionPool对应起来)。

3) 当需要数据连接时，首先得到一个DBConnectionPool，然后从DBConnectionPool中看有没有空闲的连接，如果有，则使用。如果没有，显没过最大连接数，则创建一个Connection连接，并返回这上连接。

4) 如果某个连接使用完毕，则调用DBConnectionManager.freeConnection(String name, Connection con)，它又调用DBConnectionPool. freeConnection(Connection con)，此时，连接并不真正释放，而是把这个暂时不用的Connection放到DBConnectionPool的freeConnections数组中，同时，通知其它正在等待连接的线程。这样，以后要用时，就不用再新建Connection。

原文链接：https://blog.csdn.net/zxd198612/article/details/3886917

你可能也喜欢