Java的Hibernate框架數據庫操作中鎖的使用和查詢類型

Hibernate與數據庫鎖一、為什麼要使用鎖？

要想弄清楚鎖機制存在的原因，首先要了解事務的概念。
事務是對數據庫一系列相關的操作，它必須具備ACID特徵：

• A（原子性）：要么全部成功，要么全部撤銷。
• C（一致性）：要保持數據庫的一致性。
• I（隔離性）：不同事務操作相同數據時，要有各自的數據空間。
• D（持久性）：一旦事務成功結束，它對數據庫所做的更新必須永久保持。

我們常用的關係型數據庫RDBMS實現了事務的這些特性。其中，原子性、
一致性和持久性都是採用日誌來保證的。而隔離性就是由今天我們關注的鎖機制來實現的，這就是為什麼我們需要鎖機制。

如果沒有鎖，對隔離性不加控制，可能會造成哪些後果呢？

1. 更新丟失：事務1提交的數據被事務2覆蓋。
2. 臟讀：事務2查詢到了事務1未提交的數據。
3. 虛讀：事務2查詢到了事務1提交的新建數據。
4. 不可重複讀：事務2查詢到了事務1提交的更新數據。

下面來看Hibernate的例子，兩個線程分別開啟兩個事務操作tb_account表中的同一行數據col_id=1。

 package com.cdai.orm.hibernate.annotation; import java.io.Serializable; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table; @Entity @Table(name = "tb_account") public class Account implements Serializable { private static final long serialVersionUID = 5018821760412231859L; @Id @Column(name = "col_id") private long id; @Column(name = "col_balance") private long balance; public Account() { } public Account(long id, long balance) { this.id = id; this.balance = balance; } public long getId() { return id; } public void setId(long id) { this.id = id; } public long getBalance() { return balance; } public void setBalance(long balance) { this.balance = balance; } @Override public String toString() { return "Account [id=" + id + ", balance=" + balance + "]"; } }

 package com.cdai.orm.hibernate.transaction; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import org.hibernate.cfg.AnnotationConfiguration; import com.cdai.orm.hibernate.annotation.Account; public class DirtyRead { public static void main(String[] args) { final SessionFactory sessionFactory = new AnnotationConfiguration(). addFile("hibernate/hibernate.cfg.xml"). configure(). addPackage("com.cdai.orm.hibernate.annotation"). addAnnotatedClass(Account.class). buildSessionFactory(); Thread t1 = new Thread() { @Override public void run() { Session session1 = sessionFactory.openSession(); Transaction tx1 = null; try { tx1 = session1.beginTransaction(); System.out.println("T1 - Begin trasaction"); Thread.sleep(500); Account account = (Account) session1.get(Account.class, new Long(1)); System.out.println("T1 - balance=" + account.getBalance()); Thread.sleep(500); account.setBalance(account.getBalance() + 100); System.out.println("T1 - Change balance:" + account.getBalance()); tx1.commit(); System.out.println("T1 - Commit transaction"); Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); if (tx1 != null) tx1.rollback(); } finally { session1.close(); } } }; // 3.Run transaction 2 Thread t2 = new Thread() { @Override public void run() { Session session2 = sessionFactory.openSession(); Transaction tx2 = null; try { tx2 = session2.beginTransaction(); System.out.println("T2 - Begin trasaction"); Thread.sleep(500); Account account = (Account) session2.get(Account.class, new Long(1)); System.out.println("T2 - balance=" + account.getBalance()); Thread.sleep(500); account.setBalance(account.getBalance() - 100); System.out.println("T2 - Change balance:" + account.getBalance()); tx2.commit(); System.out.println("T2 - Commit transaction"); Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); if (tx2 != null) tx2.rollback(); } finally { session2.close(); } } }; t1.start(); t2.start(); while (t1.isAlive() || t2.isAlive()) { try { Thread.sleep(2000L); } catch (InterruptedException e) { } } System.out.println("Both T1 and T2 are dead."); sessionFactory.close(); } }

事務1將col_balance減小100，而事務2將其減少100，最終結果可能是0，也可能是200，事務1或2的更新可能會丟失。 log輸出也印證了這一點，事務1和2
的log交叉打印。

 T1 - Begin trasactionT2 - Begin trasactionHibernate: select account0_.col_id as col1_0_0_, account0_.col_balance as col2_0_0_ from tb_account account0_ where account0_.col_id=?Hibernate: select account0_.col_id as col1_0_0_, account0_.col_balance as col2_0_0_ from tb_account account0_ where account0_.col_id=?T1 - balance=100T2 - balance=100T2 - Change balance:0T1 - Change balance:200Hibernate: update tb_account set col_balance=? where col_id=?Hibernate: update tb_account set col_balance=? where col_id=?T1 - Commit transactionT2 - Commit transactionBoth T1 and T2 are dead.

由此可見，隔離性是一個需要慎重考慮的問題，理解鎖很有必要。

二、有多少種鎖？

常見的有共享鎖、更新鎖和獨占鎖。

1.共享鎖：用於讀數據操作，允許其他事務同時讀取。當事務執行select語句時，
數據庫自動為事務分配一把共享鎖來鎖定讀取的數據。
2.獨占鎖：用於修改數據，其他事務不能讀取也不能修改。當事務執行insert、
update和delete時，數據庫會自動分配。
3.更新鎖：用於避免更新操作時共享鎖造成的死鎖，比如事務1和2同時持有共享鎖並等待獲得獨占鎖。當執行update時，事務先獲得更新鎖，然後將更新鎖升級成獨占鎖，這樣就避免了死鎖。

此外，這些鎖都可以施加到數據庫中不同的對像上，即這些鎖可以有不同的粒度。
如數據庫級鎖、表級鎖、頁面級鎖、鍵級鎖和行級鎖。

所以鎖是有很多種的，這麼多鎖要想完全掌握靈活使用太難了，我們又不是DBA。
怎麼辦？還好，鎖機制對於我們一般用戶來說是透明的，數據庫會自動添加合適的鎖，並在適當的時機自動升級、降級各種鎖，真是太周到了！我們只需要做的就是學會根據不同的業務需求，設置好隔離級別就可以了。

三、怎樣設置隔離級別？

一般來說，數據庫系統會提供四種事務隔離級別供用戶選擇：

1.Serializable（串行化）：當兩個事務同時操縱相同數據時，事務2只能停下來等。

2.Repeatable Read（可重複讀）：事務1能看到事務2新插入的數據，不能看到對已有數據的更新。

3.Read Commited（讀已提交數據）：事務1能看到事務2新插入和更新的數據。

4.Read Uncommited（讀未提交數據）：事務1能看到事務2沒有提交的插入和更新數據。

四、應用程序中的鎖

當數據庫採用Read Commited隔離級別時，可以在應用程序中採用悲觀鎖或樂觀鎖。

1.悲觀鎖：假定當前事務操作的數據肯定還會有其他事務訪問，因此悲觀地在應用程序中顯式指定採用獨占鎖來鎖定數據資源。在MySQL、Oracle中支持以下形式：

 select ... for update

顯式地讓select採用獨占鎖鎖定查詢的記錄，其他事務要查詢、更新或刪除這些被鎖定的數據，都要等到該事務結束後才行。

在Hibernate中，可以在load時傳入LockMode.UPGRADE來採用悲觀鎖。修改前面的例子，
在事務1和2的get方法調用處，多傳入一個LockMode參數。從log中可以看出，事務1和2
不再是交叉運行，事務2等待事務1結束後才可以讀取數據，所以最終col_balance值是正確的100。

 package com.cdai.orm.hibernate.transaction; import org.hibernate.LockMode; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.Transaction; import com.cdai.orm.hibernate.annotation.Account; import com.cdai.orm.hibernate.annotation.AnnotationHibernate; public class UpgradeLock { @SuppressWarnings("deprecation") public static void main(String[] args) { final SessionFactory sessionFactory = AnnotationHibernate.createSessionFactory(); // Run transaction 1 Thread t1 = new Thread() { @Override public void run() { Session session1 = sessionFactory.openSession(); Transaction tx1 = null; try { tx1 = session1.beginTransaction(); System.out.println("T1 - Begin trasaction"); Thread.sleep(500); Account account = (Account) session1.get(Account.class, new Long(1), LockMode.UPGRADE); System.out.println("T1 - balance=" + account.getBalance()); Thread.sleep(500); account.setBalance(account.getBalance() + 100); System.out.println("T1 - Change balance:" + account.getBalance()); tx1.commit(); System.out.println("T1 - Commit transaction"); Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); if (tx1 != null) tx1.rollback(); } finally { session1.close(); } } }; // Run transaction 2 Thread t2 = new Thread() { @Override public void run() { Session session2 = sessionFactory.openSession(); Transaction tx2 = null; try { tx2 = session2.beginTransaction(); System.out.println("T2 - Begin trasaction"); Thread.sleep(500); Account account = (Account) session2.get(Account.class, new Long(1), LockMode.UPGRADE); System.out.println("T2 - balance=" + account.getBalance()); Thread.sleep(500); account.setBalance(account.getBalance() - 100); System.out.println("T2 - Change balance:" + account.getBalance()); tx2.commit(); System.out.println("T2 - Commit transaction"); Thread.sleep(500); } catch (Exception e) { e.printStackTrace(); if (tx2 != null) tx2.rollback(); } finally { session2.close(); } } }; t1.start(); t2.start(); while (t1.isAlive() || t2.isAlive()) { try { Thread.sleep(2000L); } catch (InterruptedException e) { } } System.out.println("Both T1 and T2 are dead."); sessionFactory.close(); } }

 T1 - Begin trasactionT2 - Begin trasactionHibernate: select account0_.col_id as col1_0_0_, account0_.col_balance as col2_0_0_ from tb_account account0_ with (updlock, rowlock) where account0_.col_id=?Hibernate: select account0_.col_id as col1_0_0_, account0_.col_balance as col2_0_0_ from tb_account account0_ with (updlock, rowlock) where account0_.col_id=?T2 - balance=100T2 - Change balance:0Hibernate: update tb_account set col_balance=? where col_id=?T2 - Commit transactionT1 - balance=0T1 - Change balance:100Hibernate: update tb_account set col_balance=? where col_id=?T1 - Commit transactionBoth T1 and T2 are dead.

Hibernate對於SQLServer 2005會執行SQL：

複製代碼代碼如下:
select account0_.col_id as col1_0_0_, account0_.col_balance as col2_0_0_ from tb_account account0_ with (updlock, rowlock) where account0_.col_id=?

2.樂觀鎖：假定當前事務操作的數據不會有其他事務同時訪問，因此完全依靠數據庫的隔離級別來自動管理鎖的工作。在應用程序中採用版本控制來避免可能低概率出現的並發問題。

在Hibernate中，使用Version註解來定義版本號字段。

將DirtyLock中的Account對象替換成AccountVersion，其他代碼不變，執行出現異常。

 package com.cdai.orm.hibernate.transaction; import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence.Id; import javax.persistence.Table; import javax.persistence.Version; @Entity @Table(name = "tb_account_version") public class AccountVersion { @Id @Column(name = "col_id") private long id; @Column(name = "col_balance") private long balance; @Version @Column(name = "col_version") private int version; public AccountVersion() { } public AccountVersion(long id, long balance) { this.id = id; this.balance = balance; } public long getId() { return id; } public void setId(long id) { this.id = id; } public long getBalance() { return balance; } public void setBalance(long balance) { this.balance = balance; } public int getVersion() { return version; } public void setVersion(int version) { this.version = version; } }

log如下：

 T1 - Begin trasactionT2 - Begin trasactionHibernate: select accountver0_.col_id as col1_0_0_, accountver0_.col_balance as col2_0_0_, accountver0_.col_version as col3_0_0_ from tb_account_version accountver0_ where accountver0_.col_id=?Hibernate: select accountver0_.col_id as col1_0_0_, accountver0_.col_balance as col2_0_0_, accountver0_.col_version as col3_0_0_ from tb_account_version accountver0_ where accountver0_.col_id=?T1 - balance=1000T2 - balance=1000T1 - Change balance:900T2 - Change balance:1100Hibernate: update tb_account_version set col_balance=?, col_version=? where col_id=? and col_version=?Hibernate: update tb_account_version set col_balance=?, col_version=? where col_id=? and col_version=?T1 - Commit transaction2264 [Thread-2] ERROR org.hibernate.event.def.AbstractFlushingEventListener - Could not synchronize database state with sessionorg.hibernate.StaleObjectStateException: Row was updated or deleted by another transaction (or unsaved-value mapping was incorrect): [com.cdai.orm.hibernate.transaction.AccountVersion#1] at org.hibernate.persister.entity.AbstractEntityPersister.check(AbstractEntityPersister.java:1934) at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:2578) at org.hibernate.persister.entity.AbstractEntityPersister.updateOrInsert(AbstractEntityPersister.java:2478) at org.hibernate.persister.entity.AbstractEntityPersister.update(AbstractEntityPersister.java:2805) at org.hibernate.action.EntityUpdateAction.execute(EntityUpdateAction.java:114) at org.hibernate.engine.ActionQueue.execute(ActionQueue.java:268) at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:260) at org.hibernate.engine.ActionQueue.executeActions(ActionQueue.java:180) at org.hibernate.event.def.AbstractFlushingEventListener.performExecutions(AbstractFlushingEventListener.java:321) at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:51) at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1206) at org.hibernate.impl.SessionImpl.managedFlush(SessionImpl.java:375) at org.hibernate.transaction.JDBCTransaction.commit(JDBCTransaction.java:137) at com.cdai.orm.hibernate.transaction.VersionLock$2.run(VersionLock.java:93)Both T1 and T2 are dead.

由於樂觀鎖完全將事務隔離交給數據庫來控制，所以事務1和2交叉運行了，事務1提交成功並將col_version改為1，然而事務2提交時已經找不到col_version為0的數據了，所以拋出了異常。

Hibernate查詢方法比較
Hibernate主要有三種查詢方法：

1.HQL (Hibernate Query Language)

和SQL很類似，支持分頁、連接、分組、聚集函數和子查詢等特性，
但HQL是面向對象的，而不是面向關係數據庫中的表。正因查詢語句是面向Domain對象的，所以使用HQL可以獲得跨平台的好處，Hibernate
會自動幫我們根據不同的數據庫翻譯成不同的SQL語句。這在需要支持多種數據庫或者數據庫遷移的應用中是十分方便的。

但得到方便的同時，由於SQL語句是由Hibernate自動生成的，所以這不利於SQL語句的效率優化和調試，當數據量很大時可能會有效率問題，
出了問題也不便於排查解決。

2.QBC/QBE (Query by Criteria/Example)

QBC/QBE是通過組裝查詢條件或者模闆對象來執行查詢的。這在需要靈活地支持許多查詢條件自由組合的應用中是比較方便的。同樣的問題是由於查詢語句是自由組裝的，創建一條語句的代碼可能很長，並且包含許多分支條件，很不便於優化和調試。

3.SQL

Hibernate也支持直接執行SQL的查詢方式。這種方式犧牲了Hibernate跨數據庫的優點，手工地編寫底層SQL語句，從而獲得最好的執行效率，
相對前兩種方法，優化和調試方便了一些。

下面來看一組簡單的例子。

 package com.cdai.orm.hibernate.query; import java.util.Arrays; import java.util.List; import org.hibernate.Criteria; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.AnnotationConfiguration; import org.hibernate.criterion.Criterion; import org.hibernate.criterion.Example; import org.hibernate.criterion.Expression; import com.cdai.orm.hibernate.annotation.Account; public class BasicQuery { public static void main(String[] args) { SessionFactory sessionFactory = new AnnotationConfiguration(). addFile("hibernate/hibernate.cfg.xml"). configure(). addPackage("com.cdai.orm.hibernate.annotation"). addAnnotatedClass(Account.class). buildSessionFactory(); Session session = sessionFactory.openSession(); // 1.HQL Query query = session.createQuery("from Account as a where a.id=:id"); query.setLong("id", 1); List result = query.list(); for (Object row : result) { System.out.println(row); } // 2.QBC Criteria criteria = session.createCriteria(Account.class); criteria.add(Expression.eq("id", new Long(2))); result = criteria.list(); for (Object row : result) { System.out.println(row); } // 3.QBE Account example= new Account(); example.setBalance(100); result = session.createCriteria(Account.class). add(Example.create(example)). list(); for (Object row : result) { System.out.println(row); } // 4.SQL query = session.createSQLQuery( " select top 10 * from tb_account order by col_id desc "); result = query.list(); for (Object row : result) { System.out.println(Arrays.toString((Object[]) row)); } session.close(); } }

 Hibernate: select account0_.col_id as col1_0_, account0_.col_balance as col2_0_ from tb_account account0_ where account0_.col_id=?Account [id=1, balance=100]Hibernate: select this_.col_id as col1_0_0_, this_.col_balance as col2_0_0_ from tb_account this_ where this_.col_id=?Account [id=2, balance=100]Hibernate: select this_.col_id as col1_0_0_, this_.col_balance as col2_0_0_ from tb_account this_ where (this_.col_balance=?)Account [id=1, balance=100]Account [id=2, balance=100]Hibernate: select top 10 * from tb_account order by col_id desc[2, 100][1, 100]

從log中可以清楚的看到Hibernate對於生成的SQL語句的控制，具體選擇哪種查詢方式就要看具體應用了。