我們在使用Hibernate中經常用到當多個人對同一數據同時進行修改的時候，會發生臟數據，造成數據的不一致性，解決辦法是可以通過悲觀鎖和樂觀鎖來實現。

Hibernate悲觀鎖：在數據有加載的時候就給其進行加鎖，直到該鎖被釋放掉，其他用戶才可以進行修改，優點：數據的一致性保持得很好，缺點：不適合多個用戶并發訪問。當一個鎖住的資源不被釋放掉的時候，這個資源永遠不會被其他用戶進行修改，容易造成無限期的等待。

Hibernate樂觀鎖：就是在對數據進行修改的時候，對數據才去版本或者時間戳等方式來比較，數據是否一致性來實現加鎖。優點比較好。

一、在Hibernate悲觀鎖中，只要在加載的時候，才去session中的load方法，進行枷鎖,session.load(****.class,1,LockMode.UPDATE);

Hibernate將事務管理委托給底層的JDBC或者JTA，默認是基于JDBC Transaction的。Hibernate支持“悲觀鎖（Pessimistic Locking）”和“樂觀鎖（Optimistic Locking）”。
Hibernate悲觀鎖對數據被外界修改持保守態度，因此，在整個數據處理過程中，將數據處于鎖定狀態。Hibernate悲觀鎖的實現，往往依靠數據庫提供的鎖機制。Hibernate通過使用數據庫的for update子句實現了悲觀鎖機制。

Hibernate的加鎖模式有：

1. LockMode.NONE：無鎖機制

2. LockMode.WRITE：Hibernate在Insert和Update記錄的時候會自動獲取

3. LockMode.READ：Hibernate在讀取記錄的時候會自動獲取

4. LockMode.UPGRADE：利用數據庫的for update子句加鎖

5. LockMode.UPGRADE_NOWAIT：Oracle的特定實現，利用Oracle的for update nowait子句實現加鎖

二、樂觀鎖大多是基于數據版本（Version）記錄機制實現。Hibernate在其數據訪問引擎中內置了Hibernate樂觀鎖實現，可以通過class描述符的optimistic-lock屬性結合version描述符指定。optimistic-lock屬性有如下可選取值：

1. none：無樂觀鎖

2. version：通過版本機制實現樂觀鎖

3. dirty：通過檢查發生變動過的屬性實現樂觀鎖

4. all：通過檢查所有屬性實現樂觀鎖

例子：
1)Hibernate悲觀鎖：

1>POJO類

public class PersimisticLocking {  
 private int id;  
   
 private String Item;  
   
 private int price;  
//省略setter、getter方法  
} 

2>、POJO類的映射文件

 <?xml version="1.0"?> 
 <!DOCTYPE hibernate-mapping PUBLIC   
     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> 
 <hibernate-mapping package="org.apple.hibernate"> 
     <class name="PersimisticLocking" table="t_persimisticLocking"> 
         <id name="id"> 
             <generator class="native"/> 
         </id> 
        <property name="item"/> 
        <property name="price"/> 
    </class> 
</hibernate-mapping> 

3>、加載測試方法

public void testLoad1()  
     {  
         Session session = null;  
         try {  
             session = HibernateUtil.getSession();  
             session.beginTransaction();  
             OptimisticLocking o = (OptimisticLocking)session.load(OptimisticLocking.class, 1);  
             System.out.println("o.item="+o.getItem());  
             System.out.println("o.price="+o.getPrice());  
            System.out.println("o.version="+o.getVersion());  
            o.setPrice(o.getPrice()-10);  
            session.update(o);  
            session.beginTransaction().commit();  
        } catch (Exception e) {  
            // TODO: handle exception  
            e.printStackTrace();  
            session.beginTransaction().rollback();  
        }finally{  
            HibernateUtil.closeSession(session);  
        }  
          
    } 

可以設置另外類似的方法，不枷鎖，先對上面的測試代碼設置斷點，點debug一部分，再運行不枷鎖的，可以看到，如果上面方法不釋放鎖的話，下面的數據就會造成無限期的等待。

2、Hibernate樂觀鎖：

1>在悲觀鎖的基礎上加入private int version;和相關的setter、getter方法。

2>映射文件配置在class標簽里面加入optimistic-lock="version"，然后在的id標簽后面加入<version name="version"/>

3>測試方法：

public void testLoad1()  
     {  
         Session session = null;  
         try {  
             session = HibernateUtil.getSession();  
             session.beginTransaction();  
             OptimisticLocking o = (OptimisticLocking)session.load(OptimisticLocking.class, 1);  
             System.out.println("o.item="+o.getItem());  
             System.out.println("o.price="+o.getPrice());  
            System.out.println("o.version="+o.getVersion());  
            o.setPrice(o.getPrice()-10);  
            session.update(o);  
            session.beginTransaction().commit();  
        } catch (Exception e) {  
            // TODO: handle exception  
            e.printStackTrace();  
            session.beginTransaction().rollback();  
        }finally{  
            HibernateUtil.closeSession(session);  
        }  
          
    } 

在初始數據的時候，version為0，在沒更新一次version都會在原來的基礎上加1，通過version的版本來實現Hibernate樂觀鎖。

在上面的測試方法里面復制成另外一個方法，對上面的方法進行設置斷點，然后單步調試幾部，到***1行的時候暫停，此時對復制的另外方法運行，然后再運行完上面的方法，就會拋出異常，所以，在實際的項目開發中，可以通過對異常進行出來，這樣就會實現并發訪問。

【編輯推薦】

1. Hibernate JDBC連接詳解
2. Hibernate傳播性持久化攻略
3. Hinerbate單端關聯代理頗析
4. 深入了解Hibernate自動狀態檢測
5. 教你如何在Hibernate中實例化集合和代理