悲观锁和乐观锁

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

下面我们举例说明：

package com.june.hibernate;

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

当我们采用乐观锁时映射文件：

 <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();

 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()

 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的生命

package com.june.hibernate;

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

映射文件

<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>

生成的数据库表中


我们在来运行如下的单元测试：

    /**
    * 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);
 	   }

   }

差点忘了，在悲观锁和乐观锁的测试运行之前一定要初始化数据
舒适化数据类如下

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悲观锁和乐观锁有个比较清晰的认识！！！