`
yy_dan
  • 浏览: 64514 次
  • 性别: Icon_minigender_1
  • 来自: 湖南岳阳
最近访客 更多访客>>
社区版块
存档分类
最新评论

悲观锁和乐观锁

Hibernate单元测试SQLXML 
阅读更多
悲观锁的实现 ：悲观锁依赖于数据库机制，在整个过程中将数据锁定，其他任何人都不能读取或修改
乐观锁：
     大多数基于数据版本记录机制（Version）的实现，一般是在数据库表中加入一个version字段，还有时间戳等机制
     读取数据时将版本一同读出，之后更新数据时版本号加1，如果提交数据时版本号小于或者等于数据库中的版本号
     则认为数据是过期的否则给予更新

下面我们举例说明：
Java代码
  1. package com.june.hibernate;   
  2.   
  3. public class Inventory {   
  4.    public Integer itemNo; //物料编号   
  5.    public String itemName;//物料名称   
  6.    public int quantity; //数量   
  7.    ........//get/set方法省略   
  8. }  
package com.june.hibernate;

public class Inventory {
   public Integer itemNo; //物料编号
   public String itemName;//物料名称
   public int quantity; //数量
   ........//get/set方法省略
}


当我们采用乐观锁时映射文件：
Xml代码
  1.  <class name="com.june.hibernate.Inventory"   table="t_inventory">  
  2.        <id name="itemNo">  
  3.            <generator class="native" ></generator>  
  4.        </id>  
  5.        <property name="itemName" length="32" />  
  6.        <property name="quantity"></property>  
  7. </class>  
 <class name="com.june.hibernate.Inventory"   table="t_inventory">
	   <id name="itemNo">
	       <generator class="native" ></generator>
	   </id>
	   <property name="itemName" length="32" />
	   <property name="quantity"></property>
</class>

我们运行如下2个单元测试：
testLoad1();
Java代码
  1. public void testLoad1(){   
  2.      Session session=null;   
  3.          Transaction tx=null;   
  4.         try{   
  5.            session=HibernateUtil.getSession();   
  6.            tx=session.beginTransaction();    
  7.            Inventory inventory=(Inventory)session.load(Inventory.class,2,LockMode.UPGRADE);   
  8.            System.out.println("@inventory.id="+inventory.getItemNo());   
  9.            System.out.println("@inventory.itemName="+inventory.getItemName());   
  10.            System.out.println("@inventory.quantity="+inventory.getQuantity());   
  11.               
  12.          System.out.println("@提货减去200...............");   
  13.          inventory.setQuantity(inventory.getQuantity()-200);//(1)   
  14.               
  15.            tx.commit();   
  16.        }catch(Exception e){   
  17.            e.printStackTrace();   
  18.            tx.rollback();   
  19.        }finally{   
  20.            HibernateUtil.colseSession(session);   
  21.        }   
  22.   
  23.    }  
 public void testLoad1(){
    	 Session session=null;
  	     Transaction tx=null;
  	    try{
  		   session=HibernateUtil.getSession();
  		   tx=session.beginTransaction(); 
  	       Inventory inventory=(Inventory)session.load(Inventory.class,2,LockMode.UPGRADE);
  	       System.out.println("@inventory.id="+inventory.getItemNo());
  	       System.out.println("@inventory.itemName="+inventory.getItemName());
  	       System.out.println("@inventory.quantity="+inventory.getQuantity());
  	       
  	     System.out.println("@提货减去200...............");
  	     inventory.setQuantity(inventory.getQuantity()-200);//(1)
  	       
  		   tx.commit();
  	   }catch(Exception e){
  		   e.printStackTrace();
  		   tx.rollback();
  	   }finally{
  		   HibernateUtil.colseSession(session);
  	   }

    }

testLoad2()
Java代码
  1.  public void testLoad2(){   
  2.      Session session=null;   
  3.          Transaction tx=null;   
  4.         try{   
  5.            session=HibernateUtil.getSession();   
  6.            tx=session.beginTransaction();    
  7.            Inventory inventory=(Inventory)session.load(Inventory.class,2,LockMode.UPGRADE);   
  8.            System.out.println("#inventory.id="+inventory.getItemNo());   
  9.            System.out.println("#inventory.itemName="+inventory.getItemName());   
  10.            System.out.println("#inventory.quantity="+inventory.getQuantity());   
  11.               
  12.            System.out.println("#提货减去200...............");   
  13.            inventory.setQuantity(inventory.getQuantity()-200);   
  14.               
  15.            tx.commit();   
  16.        }catch(Exception e){   
  17.            e.printStackTrace();   
  18.            tx.rollback();   
  19.        }finally{   
  20.            HibernateUtil.colseSession(session);   
  21.        }   
  22.   
  23.    }   
  24. }  
 public void testLoad2(){
   	 Session session=null;
 	     Transaction tx=null;
 	    try{
 		   session=HibernateUtil.getSession();
 		   tx=session.beginTransaction(); 
 	       Inventory inventory=(Inventory)session.load(Inventory.class,2,LockMode.UPGRADE);
 	       System.out.println("#inventory.id="+inventory.getItemNo());
 	       System.out.println("#inventory.itemName="+inventory.getItemName());
 	       System.out.println("#inventory.quantity="+inventory.getQuantity());
 	       
 	       System.out.println("#提货减去200...............");
 	       inventory.setQuantity(inventory.getQuantity()-200);
 	       
 		   tx.commit();
 	   }catch(Exception e){
 		   e.printStackTrace();
 		   tx.rollback();
 	   }finally{
 		   HibernateUtil.colseSession(session);
 	   }

   }
}

我们用debug方法testLoad1()的方法执行时 我们让方法执行到（1）（断点一定要设置它的前面）处停止下来，我们在来运行testLoad2() 我们会发现 在加载了对象之后，也就是
执行了查询sql语句之后会停下来；当我们运行完testLoad1()之后，也就是提交了事务，解除了悲观锁之后testLoad2()才能继续运行。

乐观锁：
   我们来用数据版本来实现乐观锁
   我们来看Inventory的生命
Java代码
  1. package com.june.hibernate;   
  2.   
  3. public class Inventory {   
  4.    public Integer itemNo;   
  5.    public String itemName;   
  6.    public int quantity;   
  7.    public Integer version;   
  8.    ..............   
  9. }  
package com.june.hibernate;

public class Inventory {
   public Integer itemNo;
   public String itemName;
   public int quantity;
   public Integer version;
   ..............
}

映射文件
Xml代码
  1. <class name="com.june.hibernate.Inventory"table="t_inventory"       optimistic-lock="version">  
  2.        <id name="itemNo">  
  3.            <generator class="native" ></generator>  
  4.        </id>  
  5.             <!-- version一定要紧挨着Id-->  
  6.        <version name="version"></version>  
  7.        <property name="itemName" length="32" />  
  8.        <property name="quantity"></property>  
  9.     </class>  
<class name="com.june.hibernate.Inventory"table="t_inventory"       optimistic-lock="version">
	   <id name="itemNo">
	       <generator class="native" ></generator>
	   </id>
            <!-- version一定要紧挨着Id-->
	   <version name="version"></version>
	   <property name="itemName" length="32" />
	   <property name="quantity"></property>
	</class>

生成的数据库表中


我们在来运行如下的单元测试：
Java代码
  1.  /**  
  2.  * testLoad2()  
  3.  */  
  4. public void testLoad1(){   
  5.      Session session=null;   
  6.      Transaction tx=null;   
  7.     try{   
  8.        session=HibernateUtil.getSession();   
  9.        tx=session.beginTransaction();    
  10.        Inventory inventory=(Inventory)session.load(Inventory.class,1);   
  11.        System.out.println("@inventory.id="+inventory.getItemNo());   
  12.        System.out.println("@inventory.itemName="+inventory.getItemName());   
  13.        System.out.println("@inventory.quantity="+inventory.getQuantity());   
  14.        System.out.println("@inventroy.version="+inventory.getVersion());   
  15.        System.out.println("@提货减去200...............");   
  16.        inventory.setQuantity(inventory.getQuantity()-200);   
  17.           
  18.        tx.commit();   
  19.    }catch(Exception e){   
  20.        e.printStackTrace();   
  21.        tx.rollback();   
  22.    }finally{   
  23.        HibernateUtil.colseSession(session);   
  24.    }   
  25.   
  26.  }   
  27.  /**  
  28.  * testLoad2()  
  29.  */  
  30.  public void testLoad2(){   
  31.      Session session=null;   
  32.     Transaction tx=null;   
  33.    try{   
  34.    session=HibernateUtil.getSession();   
  35.    tx=session.beginTransaction();    
  36.       Inventory inventory=(Inventory)session.load(Inventory.class,1);   
  37.       System.out.println("#inventory.id="+inventory.getItemNo());   
  38.       System.out.println("#inventory.itemName="+inventory.getItemName());   
  39.       System.out.println("#inventory.quantity="+inventory.getQuantity());   
  40.          
  41.       System.out.println("#提货减去200...............");   
  42.       inventory.setQuantity(inventory.getQuantity()-200);   
  43.          
  44.    tx.commit();   
  45.   }catch(Exception e){   
  46.    e.printStackTrace();   
  47.    tx.rollback();   
  48.   }finally{   
  49.    HibernateUtil.colseSession(session);   
  50.   }   
  51.   
  52. }  
    /**
    * testLoad2()
    */
   public void testLoad1(){
    	 Session session=null;
  	     Transaction tx=null;
  	    try{
  		   session=HibernateUtil.getSession();
  		   tx=session.beginTransaction(); 
  	       Inventory inventory=(Inventory)session.load(Inventory.class,1);
  	       System.out.println("@inventory.id="+inventory.getItemNo());
  	       System.out.println("@inventory.itemName="+inventory.getItemName());
  	       System.out.println("@inventory.quantity="+inventory.getQuantity());
  	       System.out.println("@inventroy.version="+inventory.getVersion());
  	       System.out.println("@提货减去200...............");
  	       inventory.setQuantity(inventory.getQuantity()-200);
  	       
  		   tx.commit();
  	   }catch(Exception e){
  		   e.printStackTrace();
  		   tx.rollback();
  	   }finally{
  		   HibernateUtil.colseSession(session);
  	   }

    }
    /**
    * testLoad2()
    */
    public void testLoad2(){
   	 Session session=null;
 	     Transaction tx=null;
 	    try{
 		   session=HibernateUtil.getSession();
 		   tx=session.beginTransaction(); 
 	       Inventory inventory=(Inventory)session.load(Inventory.class,1);
 	       System.out.println("#inventory.id="+inventory.getItemNo());
 	       System.out.println("#inventory.itemName="+inventory.getItemName());
 	       System.out.println("#inventory.quantity="+inventory.getQuantity());
 	       
 	       System.out.println("#提货减去200...............");
 	       inventory.setQuantity(inventory.getQuantity()-200);
 	       
 		   tx.commit();
 	   }catch(Exception e){
 		   e.printStackTrace();
 		   tx.rollback();
 	   }finally{
 		   HibernateUtil.colseSession(session);
 	   }

   }

差点忘了，在悲观锁和乐观锁的测试运行之前一定要初始化数据
舒适化数据类如下
Java代码
  1. import org.hibernate.Session;   
  2. import org.hibernate.Transaction;   
  3.   
  4. public class InitialData {   
  5.    public static void main(String args[]){       
  6.              Session session=null;   
  7.              Transaction tx=null;   
  8.             try{   
  9.                session=HibernateUtil.getSession();   
  10.                tx=session.beginTransaction();    
  11.                Inventory inventory=new Inventory();   
  12.                inventory.setItemName("Viager");   
  13.                inventory.setQuantity(1000);   
  14.                session.save(inventory);   
  15.                tx.commit();   
  16.            }catch(Exception e){   
  17.                e.printStackTrace();   
  18.                tx.rollback();   
  19.            }finally{   
  20.                HibernateUtil.colseSession(session);   
  21.            }       
  22.    }   
  23. }  
import org.hibernate.Session;
import org.hibernate.Transaction;

public class InitialData {
   public static void main(String args[]){	  
	    	 Session session=null;
	  	     Transaction tx=null;
	  	    try{
	  		   session=HibernateUtil.getSession();
	  		   tx=session.beginTransaction(); 
	  	       Inventory inventory=new Inventory();
	  	       inventory.setItemName("Viager");
	  	       inventory.setQuantity(1000);
	  		   session.save(inventory);
	  		   tx.commit();
	  	   }catch(Exception e){
	  		   e.printStackTrace();
	  		   tx.rollback();
	  	   }finally{
	  		   HibernateUtil.colseSession(session);
	  	   }	
   }
}

通过以上的测试  我们可以对Hibernate悲观锁和乐观锁有个比较清晰的认识！！！
分享到：
| Hibernate的一级缓存
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    数据库事务、hibernate悲观锁和乐观锁

    在处理并发问题时，Hibernate提供了悲观锁和乐观锁两种机制。 悲观锁假设并发环境中的冲突是常态，因此在读取数据时就立即锁定，直到事务结束才释放。在Hibernate中，可以通过设置`@LockModeType.PESSIMISTIC_READ`...

    Hibernate悲观锁和乐观锁的实现

    悲观锁和乐观锁是两种常见的锁定策略，它们各有特点，适用于不同的场景。 **悲观锁**（Pessimistic Lock）的名字来源于其悲观的态度，它认为数据随时可能被其他事务修改，因此在读取数据时就立即进行加锁，防止其他...

    Java 中的悲观锁和乐观锁的实现

    悲观锁和乐观锁各有优缺点，选择哪种锁机制取决于具体的应用场景和需求。悲观锁适合数据修改频繁且对数据一致性要求较高的场景；而乐观锁适用于数据修改较少且并发量较大的场景。在实际应用中，可以根据具体情况灵活...

    Hibernate锁机制_悲观锁和乐观锁

    Hibernate 锁机制_悲观锁和乐观锁 Hibernate 锁机制是指在... Hibernate 的锁机制可以分为悲观锁和乐观锁两种，悲观锁通过数据库层次的锁定来实现，而乐观锁通过应用程序上的逻辑实现版本控制的方法来维护正确的数据。

    并发控制—悲观锁和乐观锁

    并发控制—悲观锁和乐观锁

    悲观锁和乐观锁的技术对比和应用.docx

    悲观锁和乐观锁是两种常见的并发控制策略，用于在多任务环境下确保数据一致性。它们各自有不同的工作原理和适用场景。 悲观锁（Pessimistic Lock）正如其名，它假设并发环境中会发生频繁的冲突，因此在读取数据时就...

    十三、关于悲观锁和乐观锁.xmind

    十三、关于悲观锁和乐观锁

    Hibernate实现悲观锁和乐观锁代码介绍

    Hibernate 实现悲观锁和乐观锁代码介绍 Hibernate 是一个基于 Java 的持久层框架，它提供了多种锁机制来实现事务的隔离性和一致性。在本文中，我们将详细介绍 Hibernate 实现悲观锁和乐观锁的代码实现，并讨论 ...

    36谈谈MySQL支持的事务隔离级别，以及悲观锁和乐观锁的原理和应用场景？

    36谈谈MySQL支持的事务隔离级别，以及悲观锁和乐观锁的原理和应用场景？

    悲观锁和乐观锁.md

    所谓乐观锁，重视假设最好的情况，每次去拿数据都认为别人不会修改，所以不会上锁，但是会在更新时判断一下在此期间这个数据有没有更改，使用版本号机制和CAS算法实现，乐观锁适用于多读的应用类型，这样可以提高...

    乐观锁与悲观锁

    介绍数据库事务的定义和事务带来的问题，详细讲解乐观锁与悲观锁的区别

    面试必备之乐观锁与悲观锁.pdf

    ### 面试必备之乐观锁与悲观锁详解 #### 一、悲观锁与乐观锁的概念 悲观锁和乐观锁是计算机科学中用于处理并发控制的两种不同策略，它们主要应用于多线程环境下数据的一致性和完整性保护。两种锁的设计哲学反映了...

    Hibernate悲观锁与乐观锁案例

    在Java的持久化框架Hibernate中，悲观锁和乐观锁是两种重要的并发控制策略，它们用于管理数据库中的数据在多线程环境下的访问安全。本文将深入探讨这两种锁机制的原理、应用场景及其区别。 首先，我们来理解悲观锁...

    thinkPHP框架乐观锁和悲观锁实例分析

    在ThinkPHP框架中，常见的有乐观锁和悲观锁两种机制。本文将通过实例分析这两种锁在ThinkPHP框架中的应用，以及它们各自的优缺点。 首先，让我们从乐观锁开始了解。乐观锁机制假设多个事务在处理数据时很少发生冲突...

    Hibernate悲观锁与乐观锁

    总结来说，Hibernate的悲观锁和乐观锁是两种不同的并发控制策略，悲观锁倾向于预防并发冲突，适合并发较低但需要保证数据一致性的情景；而乐观锁则在并发较高的情况下更优，通过版本控制减少锁定，但在冲突处理上...

    面试必备之乐观锁与悲观锁

    【描述】：“面试必备之乐观锁与悲观锁.pdf”涉及的是并发控制中的两种重要锁机制——悲观锁和乐观锁，它们是多线程环境下确保数据一致性的重要手段。 【标签】：“求职面试 多线程” 【正文】： 悲观锁和乐观锁...

Magicbox
Global site tag (gtag.js) - Google Analytics