hibernate 乐观锁与悲观锁使用

Hibernate支持两种锁机制： 
即通常所说的“悲观锁（Pessimistic Locking）”和 “乐观锁（OptimisticLocking）”。 

悲观锁的实现，往往依靠数据库提供的锁机制（也只有数据库层提供的锁机制才能真正保证数据访问的排他性，否则，即使在本系统中实现了加锁机制，也无法保证外部系统不会修改数据）。 

Hibernate的加锁模式有： 
Ø LockMode.NONE ： 无锁机制。 
Ø LockMode.WRITE ：Hibernate在Insert和Update记录的时候会自动 
获取。 
Ø LockMode.READ ： Hibernate在读取记录的时候会自动获取。 
以上这三种锁机制一般由Hibernate内部使用，如Hibernate为了保证Update 
过程中对象不会被外界修改，会在save方法实现中自动为目标对象加上WRITE锁。 
Ø LockMode.UPGRADE ：利用数据库的for update子句加锁。 
Ø LockMode. UPGRADE_NOWAIT ：Oracle的特定实现，利用Oracle的for update nowait子句实现加锁。 

 Hibernate的悲观锁，也是基于数据库的锁机制实现。 下面的代码实现了对查询记录的加锁：

1     String hqlStr    =       "   from TUser as user where user.name=’Erica’   "   ; 
2   Query query    =    session.createQuery(hqlStr); 
3   query.setLockMode(   "   user   "   ,LockMode.UPGRADE);    //   加锁   
4     List userList    =    query.list();   //   执行查询，

获取数据  query.setLockMode   对查询语句中特定别名所对应的记录进行加锁（我们为 TUser类指定了一个别名“user”），这里也就是对返回的所有user记录进行加锁。 观察运行期Hibernate生成的SQL语句：

1     select tuser0_.id as id, tuser0_.name as name, tuser0_.group_id as group_id, tuser0_.user_type as user_type, tuser0_.sex as sex from t_user tuser0_ where (tuser0_.name   =   ’Erica’ )    for    update

 这里Hibernate通过使用数据库的for update子句实现了悲观锁 机制。 

上面这两种锁机制是我们在应用层较为常用的，加锁一般通过以下方法实现： 
Criteria.setLockMode 
Query.setLockMode 
Session.lock 
注意，只有在查询开始之前（也就是Hiberate 生成SQL 之前）设定加锁，才会 真正通过数据库的锁机制进行加锁处理，否则，数据已经通过不包含for update 子句的Select SQL加载进来，所谓数据库加锁也就无从谈起。

乐观锁，大多是基于数据版本（Version）记录机制实现。何谓数据版本？即为数据增加一个版本标识，在基于数据库表的版本解决方案中，一般是通过为数据库表增加一个“version”字段来实现。读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行比对，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。 

1． 首先为TUser的class描述符添加optimistic-lock属性：

  <   hibernate   -   mapping   >    
  <   class    
name   =   "   org.hibernate.sample.TUser   "    
table   =   "   t_user   "    
dynamic   -   update   =   "   true   "    
dynamic   -   insert   =   "   true   "    
optimistic   -   lock   =   "   version   "    
  >    
…… 
  </   class   >    
  </   hibernate   -   mapping   >    

 

 添加一个Version属性描述符 
代码内容

 1     <   hibernate   -   mapping   >     
 2     <   class     
 3   name   =   "   org.hibernate.sample.TUser   "     
 4   table   =   "   t_user   "     
 5   dynamic   -   update   =   "   true   "     
 6   dynamic   -   insert   =   "   true   "     
 7   optimistic   -   lock   =   "   version   "     
 8     >     
 9     <   id  
10   name   =   "   id   "     
11   column   =   "   id   "     
12   type   =   "   java.lang.Integer   "     
13     >     
14     <   generator    class   =   "   native   "   >     
15     </   generator   >     
16     </   id   >     
17     <   version  
18   column   =   "   version   "     
19   name   =   "   version   "     
20   type   =   "   java.lang.Integer   "     
21     />     
22   ……  
23     </   class   >     
24     </   hibernate   -   mapping   >     
25  

 

注意version 节点必须出现在ID 节点之后。
 这里我们声明了一个version属性，用于存放用户的版本信息，保存在TUser表的 version字段中。 此时如果我们尝试编写一段代码，更新TUser表中记录数据，如：
代码内容

1     Criteria criteria    =    session.createCriteria(TUser.   class   );  
2   criteria.add(Expression.eq(   "   name   "   ,   "   Erica   "   ));  
3   List userList    =    criteria.list();  
4   TUser user    =   (TUser)userList.get(   0   );  
5   Transaction tx    =    session.beginTransaction();  
6   user.setUserType(   1   );    //   更新UserType字段    
7     tx.commit();  
8  

每次对TUser进行更新的时候，我们可以发现，数据库中的version都在递增。 而如果我们尝试在tx.commit 之前，启动另外一个Session，对名为Erica 的用 户进行操作，以模拟并发更新时的情形： 
代码内容

 1     Session session   =    getSession();  
 2   Criteria criteria    =    session.createCriteria(TUser.   class   );  
 3   criteria.add(Expression.eq(   "   name   "   ,   "   Erica   "   ));  
 4   Session session2    =    getSession();  
 5   Criteria criteria2    =    session2.createCriteria(TUser.   class   );  
 6   criteria2.add(Expression.eq(   "   name   "   ,   "   Erica   "   ));  
 7   List userList    =    criteria.list();  
 8   List userList2    =    criteria2.list();TUser user    =   (TUser)userList.get(   0   );  
 9   TUser user2    =   (TUser)userList2.get(   0   );  
10   Transaction tx    =    session.beginTransaction();  
11   Transaction tx2    =    session2.beginTransaction();  
12   user2.setUserType(   99   );  
13   tx2.commit();  
14   user.setUserType(   1   );  
15   tx.commit();  
16  

执行以上代码，代码将在tx.commit()处抛出StaleObjectStateException 异 常，并指出版本检查失败，当前事务正在试图提交一个过期数据。通过捕捉这个异常，我 们就可以在乐观锁校验失败时进行相应处理。 

悲观锁与乐观锁的比较: 
悲观锁大多数情况下依靠数据库的锁机制实现，以保证操作最大程度的独占性。但随之而来的就是数据库性能的大量开销，特别是对长事务而言，这样的开销往往无法承受; 
相对悲观锁而言，乐观锁机制采取了更加宽松的加锁机制。乐观锁机制往往基于系统中的数据存储逻辑，因此也具备一定的局限性，如在上例中，由于乐观锁机制是在我们的系统中实现，来自外部系统的更新操作不受我们系统的控制，因此可能会造成脏数据被更新到数据库中。在 
系统设计阶段，我们应该充分考虑到这些情况出现的可能性，并进行相应调整（如将乐观锁策略在数据库存储过程中实现，对外只开放基于此存储过程的数据更新途径，而不是将数据库表直接对外公开）。 
Hibernate 在其数据访问引擎中内置了乐观锁实现。如果不用考虑外部系统对数据库的更新操作，利用Hibernate提供的透明化乐观锁实现，将大大提升我们的生产力。 
Hibernate中可以通过class描述符的optimistic-lock属性结合version描述符指定。 
optimistic-lock属性有如下可选取值： 
Ø none 
无乐观锁 
Ø version 
通过版本机制实现乐观锁 
Ø dirty 
通过检查发生变动过的属性实现乐观锁 
Ø all 
通过检查所有属性实现乐观锁 
其中通过version实现的乐观锁机制是Hibernate官方推荐的乐观锁实现，同时也是Hibernate中，目前唯一在数据对象脱离Session发生修改的情况下依然有效的锁机制。因此，一般情况下，我们都选择version方式作为Hibernate乐观锁实现机制。

 

转自：http://www.blogjava.net/baoyaer/articles/203445.html