數據庫樂觀鎖和悲觀鎖

轉自：博客園https://www.cnblogs.com/vianzhang/p/7922376.html

以下是轉載的oracle和Mysql兩種數據庫悲觀鎖和樂觀鎖機制及樂觀鎖實現方式：

一、Oracle

Oracle數據庫悲觀鎖與樂觀鎖是本文我們主要要介紹的內容。有時候爲了得到最大的性能，一般數據庫都有併發機制，不過帶來的問題就是數據訪問的衝突。爲了解決這個問題，大多數數據庫用的方法就是數據的鎖定。

數據的鎖定分爲兩種方法，第一種叫做悲觀鎖，第二種叫做樂觀鎖。什麼叫悲觀鎖呢，悲觀鎖顧名思義，就是對數據的衝突採取一種悲觀的態度，也就是說假設數據肯定會衝突，所以在數據開始讀取的時候就把數據鎖定住。而樂觀鎖就是認爲數據一般情況下不會造成衝突，所以在數據進行提交更新的時候，纔會正式對數據的衝突與否進行檢測，如果發現衝突了，則讓用戶返回錯誤的信息，讓用戶決定如何去做。

先從悲觀鎖開始說。在SqlServer等其餘很多數據庫中，數據的鎖定通常採用頁級鎖的方式，也就是說對一張表內的數據是一種串行化的更新插入機制，在任何時間同一張表只會插1條數據，別的想插入的數據要等到這一條數據插完以後才能依次插入。帶來的後果就是性能的降低，在多用戶併發訪問的時候，當對一張表進行頻繁操作時，會發現響應效率很低，數據庫經常處於一種假死狀態。而Oracle用的是行級鎖，只是對想鎖定的數據才進行鎖定，其餘的數據不相干，所以在對Oracle表中併發插數據的時候，基本上不會有任何影響。

注：對於悲觀鎖是針對併發的可能性比較大，而一般在我們的應用中用樂觀鎖足以。

Oracle的悲觀鎖需要利用一條現有的連接，分成兩種方式，從SQL語句的區別來看，就是一種是for update，一種是for update nowait的形式。比如我們看一個例子。首先建立測試用的數據庫表。

CREATE TABLE TEST(ID,NAME,LOCATION,VALUE,CONSTRAINT test_pk PRIMARY KEY(ID))AS SELECT deptno, dname, loc, 1 FROM scott.dept

這裏我們利用了Oracle的Sample的scott用戶的表，把數據copy到我們的test表中。首先我們看一下for update鎖定方式。首先我們執行如下的select for update語句。

select * from test where id = 10 for update

通過這條檢索語句鎖定以後，再開另外一個sql*plus窗口進行操作，再把上面這條sql語句執行一便，你會發現sqlplus好像死在那裏了，好像檢索不到數據的樣子，但是也不返回任何結果，就屬於卡在那裏的感覺。這個時候是什麼原因呢，就是一開始的第一個Session中的select for update語句把數據鎖定住了。由於這裏鎖定的機制是wait的狀態(只要不表示nowait那就是wait)，所以第二個Session(也就是卡住的那個sql*plus)中當前這個檢索就處於等待狀態。當第一個session最後commit或者rollback之後，第二個session中的檢索結果就是自動跳出來，並且也把數據鎖定住。不過如果你第二個session中你的檢索語句如下所示。

select * from test where id = 10

也就是沒有for update這種鎖定數據的語句的話，就不會造成阻塞了。另外一種情況，就是當數據庫數據被鎖定的時候，也就是執行剛纔for update那條sql以後，我們在另外一個session中執行for update nowait後又是什麼樣呢。比如如下的sql語句。 由於這條語句中是制定採用nowait方式來進行檢索，所以當發現數據被別的session鎖定中的時候，就會迅速返回ORA-00054錯誤，內容是資源正忙, 但指定以 NOWAIT 方式獲取資源。所以在程序中我們可以採用nowait方式迅速判斷當前數據是否被鎖定中，如果鎖定中的話，就要採取相應的業務措施進行處理。

select * from test where id = 10 for update nowait

那這裏另外一個問題，就是當我們鎖定住數據的時候，我們對數據進行更新和刪除的話會是什麼樣呢。比如同樣，我們讓第一個Session鎖定住id=10的那條數據，我們在第二個session中執行如下語句。

update test set value=2 where id = 10

這個時候我們發現update語句就好像select for update語句一樣也停住卡在這裏，當你第一個session放開鎖定以後update才能正常運行。當你update運行後，數據又被你update語句鎖定住了，這個時候只要你update後還沒有commit，別的session照樣不能對數據進行鎖定更新等等。

總之，Oracle中的悲觀鎖就是利用Oracle的Connection對數據進行鎖定。在Oracle中，用這種行級鎖帶來的性能損失是很小的，只是要注意程序邏輯，不要給你一不小心搞成死鎖了就好。而且由於數據的及時鎖定，在數據提交時候就不呼出現衝突，可以省去很多惱人的數據衝突處理。缺點就是你必須要始終有一條數據庫連接，就是說在整個鎖定到最後放開鎖的過程中，你的數據庫聯接要始終保持住。與悲觀鎖相對的，我們有了樂觀鎖。樂觀鎖一開始也說了，就是一開始假設不會造成數據衝突，在最後提交的時候再進行數據衝突檢測。

在樂觀鎖中，我們有3種常用的做法來實現：

[1]第一種就是在數據取得的時候把整個數據都copy到應用中，在進行提交的時候比對當前數據庫中的數據和開始的時候更新前取得的數據。當發現兩個數據一模一樣以後，就表示沒有衝突可以提交，否則則是併發衝突，需要去用業務邏輯進行解決。

[2]第二種樂觀鎖的做法就是採用版本戳，這個在Hibernate中得到了使用。採用版本戳的話，首先需要在你有樂觀鎖的數據庫table上建立一個新的column，比如爲number型，當你數據每更新一次的時候，版本數就會往上增加1。比如同樣有2個session同樣對某條數據進行操作。兩者都取到當前的數據的版本號爲1，當第一個session進行數據更新後，在提交的時候查看到當前數據的版本還爲1，和自己一開始取到的版本相同。就正式提交，然後把版本號增加1，這個時候當前數據的版本爲2。

當第二個session也更新了數據提交的時候，發現數據庫中版本爲2，和一開始這個session取到的版本號不一致，就知道別人更新過此條數據，這個時候再進行業務處理，比如整個Transaction都Rollback等等操作。在用版本戳的時候，可以在應用程序側使用版本戳的驗證，也可以在數據庫側採用Trigger(觸發器)來進行驗證。不過數據庫的Trigger的性能開銷還是比較的大，所以能在應用側進行驗證的話還是推薦不用Trigger。

[3]第三種做法和第二種做法有點類似，就是也新增一個Table的Column，不過這次這個column是採用timestamp型，存儲數據最後更新的時間。在Oracle9i以後可以採用新的數據類型，也就是timestamp with time zone類型來做時間戳。這種Timestamp的數據精度在Oracle的時間類型中是最高的，精確到微秒(還沒與到納秒的級別)，一般來說，加上數據庫處理時間和人的思考動作時間，微秒級別是非常非常夠了，其實只要精確到毫秒甚至秒都應該沒有什麼問題。和剛纔的版本戳類似，也是在更新提交的時候檢查當前數據庫中數據的時間戳和自己更新前取到的時間戳進行對比，如果一致則OK，否則就是版本衝突。如果不想把代碼寫在程序中或者由於別的原因無法把代碼寫在現有的程序中，也可以把這個時間戳樂觀鎖邏輯寫在Trigger或者存儲過程中

二、Mysql（轉自：http://chenzhou123520.iteye.com/blog/1860954）

悲觀鎖介紹（百科）：

悲觀鎖，正如其名，它指的是對數據被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度，因此，在整個數據處理過程中，將數據處於鎖定狀態。悲觀鎖的實現，往往依靠數據庫提供的鎖機制（也只有數據庫層提供的鎖機制才能真正保證數據訪問的排他性，否則，即使在本系統中實現了加鎖機制，也無法保證外部系統不會修改數據）。

 

使用場景舉例：以MySQL InnoDB爲例

商品goods表中有一個字段status，status爲1代表商品未被下單，status爲2代表商品已經被下單，那麼我們對某個商品下單時必須確保該商品status爲1。假設商品的id爲1。

 

1如果不採用鎖，那麼操作方法如下：

//1.查詢出商品信息

select status from t_goods where id=1;

//2.根據商品信息生成訂單

insert into t_orders (id,goods_id) values (null,1);

//3.修改商品status爲2

update t_goods set status=2;

 

上面這種場景在高併發訪問的情況下很可能會出現問題。

前面已經提到，只有當goods status爲1時才能對該商品下單，上面第一步操作中，查詢出來的商品status爲1。但是當我們執行第三步Update操作的時候，有可能出現其他人先一步對商品下單把goods status修改爲2了，但是我們並不知道數據已經被修改了，這樣就可能造成同一個商品被下單2次，使得數據不一致。所以說這種方式是不安全的。

 

2使用悲觀鎖來實現：

在上面的場景中，商品信息從查詢出來到修改，中間有一個處理訂單的過程，使用悲觀鎖的原理就是，當我們在查詢出goods信息後就把當前的數據鎖定，直到我們修改完畢後再解鎖。那麼在這個過程中，因爲goods被鎖定了，就不會出現有第三者來對其進行修改了。

 

注：要使用悲觀鎖，我們必須關閉mysql數據庫的自動提交屬性，因爲MySQL默認使用autocommit模式，也就是說，當你執行一個更新操作後，MySQL會立刻將結果進行提交。

 

我們可以使用命令設置MySQL爲非autocommit模式：

set autocommit=0;

 

設置完autocommit後，我們就可以執行我們的正常業務了。具體如下：

//0.開始事務

begin;/begin work;/start transaction; (三者選一就可以)

//1.查詢出商品信息

select status from t_goods where id=1 for update;

//2.根據商品信息生成訂單

insert into t_orders (id,goods_id) values (null,1);

//3.修改商品status爲2

update t_goods set status=2;

//4.提交事務

commit;/commit work;

 

注：上面的begin/commit爲事務的開始和結束，因爲在前一步我們關閉了mysql的autocommit，所以需要手動控制事務的提交，在這裏就不細表了。

 

上面的第一步我們執行了一次查詢操作：select status from t_goods where id=1 for update;

與普通查詢不一樣的是，我們使用了select…for update的方式，這樣就通過數據庫實現了悲觀鎖。此時在t_goods表中，id爲1的 那條數據就被我們鎖定了，其它的事務必須等本次事務提交之後才能執行。這樣我們可以保證當前的數據不會被其它事務修改。

 

注：需要注意的是，在事務中，只有SELECT ... FOR UPDATE 或LOCK IN SHARE MODE 同一筆數據時會等待其它事務結束後才執行，一般SELECT ... 則不受此影響。拿上面的實例來說，當我執行select status from t_goods where id=1 for update;後。我在另外的事務中如果再次執行select status from t_goods where id=1 for update;則第二個事務會一直等待第一個事務的提交，此時第二個查詢處於阻塞的狀態，但是如果我是在第二個事務中執行select status from t_goods where id=1;則能正常查詢出數據，不會受第一個事務的影響。

 

補充：MySQL select…for update的Row Lock與Table Lock

上面我們提到，使用select…for update會把數據給鎖住，不過我們需要注意一些鎖的級別，MySQL InnoDB默認Row-Level Lock，所以只有「明確」地指定主鍵，MySQL 纔會執行Row lock (只鎖住被選取的數據) ，否則MySQL 將會執行Table Lock (將整個數據表單給鎖住)。

 

舉例說明：

數據庫表t_goods，包括id,status,name三個字段，id爲主鍵，數據庫中記錄如下;

Sql代碼 

1. mysql> select * from t_goods;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  1 |      1 | 道具 |   
6. |  2 |      1 | 裝備 |   
7. +----+--------+------+   
8. 2 rows in set  
9.   
10. mysql>  

mysql> select * from t_goods;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 ||  2 |      1 | 裝備 |+----+--------+------+2 rows in setmysql>

注：爲了測試數據庫鎖，我使用兩個console來模擬不同的事務操作，分別用console1、console2來表示。 

 

例1: (明確指定主鍵，並且有此數據，row lock)

console1：查詢出結果，但是把該條數據鎖定了

Sql代碼 

1. mysql> select * from t_goods where id=1 for update;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  1 |      1 | 道具 |   
6. +----+--------+------+   
7. 1 row in set  
8.   
9. mysql>  

mysql> select * from t_goods where id=1 for update;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 |+----+--------+------+1 row in setmysql>

console2：查詢被阻塞

Sql代碼 

1. mysql> select * from t_goods where id=1 for update;  

mysql> select * from t_goods where id=1 for update;

console2：如果console1長時間未提交，則會報錯

Sql代碼 

1. mysql> select * from t_goods where id=1 for update;   
2. ERROR 1205 : Lock wait timeout exceeded; try restarting transaction  

mysql> select * from t_goods where id=1 for update;ERROR 1205 : Lock wait timeout exceeded; try restarting transaction

 

例2: (明確指定主鍵，若查無此數據，無lock)

console1：查詢結果爲空

Sql代碼 

1. mysql> select * from t_goods where id=3 for update;   
2. Empty set  

mysql> select * from t_goods where id=3 for update;Empty set

console2：查詢結果爲空，查詢無阻塞，說明console1沒有對數據執行鎖定

Sql代碼 

1. mysql> select * from t_goods where id=3 for update;   
2. Empty set  

mysql> select * from t_goods where id=3 for update;Empty set

 

例3: (無主鍵，table lock)

console1：查詢name=道具 的數據，查詢正常

Sql代碼 

1. mysql> select * from t_goods where name='道具' for update;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  1 |      1 | 道具 |   
6. +----+--------+------+   
7. 1 row in set  
8.   
9. mysql>  

mysql> select * from t_goods where name='道具' for update;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 |+----+--------+------+1 row in setmysql>

console2：查詢name=裝備 的數據，查詢阻塞，說明console1把表給鎖住了

Sql代碼 

1. mysql> select * from t_goods where name='裝備' for update;  

mysql> select * from t_goods where name='裝備' for update;

console2：若console1長時間未提交，則查詢返回爲空

Sql代碼 

1. mysql> select * from t_goods where name='裝備' for update;   
2. Query OK, -1 rows affected  

mysql> select * from t_goods where name='裝備' for update;Query OK, -1 rows affected

 

例4: (主鍵不明確，table lock)

console1：查詢正常

Sql代碼 

1. mysql> begin;   
2. Query OK, 0 rows affected   
3.   
4. mysql> select * from t_goods where id>0 for update;   
5. +----+--------+------+   
6. | id | status | name |   
7. +----+--------+------+   
8. |  1 |      1 | 道具 |   
9. |  2 |      1 | 裝備 |   
10. +----+--------+------+   
11. 2 rows in set  
12.   
13. mysql>  

mysql> begin;Query OK, 0 rows affectedmysql> select * from t_goods where id>0 for update;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 ||  2 |      1 | 裝備 |+----+--------+------+2 rows in setmysql>

console2：查詢被阻塞，說明console1把表給鎖住了

Sql代碼 

1. mysql> select * from t_goods where id>1 for update;  

mysql> select * from t_goods where id>1 for update;

 

例5: (主鍵不明確，table lock)

console1：

Sql代碼 

1. mysql> begin;   
2. Query OK, 0 rows affected   
3.   
4. mysql> select * from t_goods where id<>1 for update;   
5. +----+--------+------+   
6. | id | status | name |   
7. +----+--------+------+   
8. |  2 |      1 | 裝備 |   
9. +----+--------+------+   
10. 1 row in set  
11.   
12. mysql>  

mysql> begin;Query OK, 0 rows affectedmysql> select * from t_goods where id<>1 for update;+----+--------+------+| id | status | name |+----+--------+------+|  2 |      1 | 裝備 |+----+--------+------+1 row in setmysql>

console2：查詢被阻塞，說明console1把表給鎖住了

Sql代碼 

1. mysql> select * from t_goods where id<>2 for update;  

mysql> select * from t_goods where id<>2 for update;

console1：提交事務

Sql代碼 

1. mysql> commit;   
2. Query OK, 0 rows affected  

mysql> commit;Query OK, 0 rows affected

console2：console1事務提交後，console2查詢結果正常

Sql代碼 

1. mysql> select * from t_goods where id<>2 for update;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  1 |      1 | 道具 |   
6. +----+--------+------+   
7. 1 row in set  
8.   
9. mysql>  

mysql> select * from t_goods where id<>2 for update;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 |+----+--------+------+1 row in setmysql>

 

以上就是關於數據庫主鍵對MySQL鎖級別的影響實例，需要注意的是，除了主鍵外，使用索引也會影響數據庫的鎖定級別

 

舉例：

我們修改t_goods表，給status字段創建一個索引

修改id爲2的數據的status爲2，此時表中數據爲：

Sql代碼 

1. mysql> select * from t_goods;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  1 |      1 | 道具 |   
6. |  2 |      2 | 裝備 |   
7. +----+--------+------+   
8. 2 rows in set  
9.   
10. mysql>  

mysql> select * from t_goods;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 ||  2 |      2 | 裝備 |+----+--------+------+2 rows in setmysql>

 

例6: (明確指定索引，並且有此數據，row lock)

console1：

Sql代碼 

1. mysql> select * from t_goods where status=1 for update;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  1 |      1 | 道具 |   
6. +----+--------+------+   
7. 1 row in set  
8.   
9. mysql>  

mysql> select * from t_goods where status=1 for update;+----+--------+------+| id | status | name |+----+--------+------+|  1 |      1 | 道具 |+----+--------+------+1 row in setmysql>

console2：查詢status=1的數據時阻塞，超時後返回爲空，說明數據被console1鎖定了

Sql代碼 

1. mysql> select * from t_goods where status=1 for update;   
2. Query OK, -1 rows affected  

mysql> select * from t_goods where status=1 for update;Query OK, -1 rows affected

console2：查詢status=2的數據，能正常查詢，說明console1只鎖住了行，未鎖表

Sql代碼 

1. mysql> select * from t_goods where status=2 for update;   
2. +----+--------+------+   
3. | id | status | name |   
4. +----+--------+------+   
5. |  2 |      2 | 裝備 |   
6. +----+--------+------+   
7. 1 row in set  
8.   
9. mysql>  

mysql> select * from t_goods where status=2 for update;+----+--------+------+| id | status | name |+----+--------+------+|  2 |      2 | 裝備 |+----+--------+------+1 row in setmysql>

 

例7: (明確指定索引，若查無此數據，無lock)

console1：查詢status=3的數據，返回空數據

Sql代碼 

1. mysql> select * from t_goods where status=3 for update;   
2. Empty set  

mysql> select * from t_goods where status=3 for update;Empty set

console2：查詢status=3的數據，返回空數據

Sql代碼 

1. mysql> select * from t_goods where status=3 for update;   
2. Empty set  

mysql> select * from t_goods where status=3 for update;Empty set

 

 

以上就是關於我對數據庫悲觀鎖的理解和總結，有不對的地方歡迎拍磚，下一次會帶來數據庫樂觀鎖的總結和實踐

 

參考資料：

MySQL事務與鎖定命令：http://www.docin.com/p-16805970.html

悲觀鎖：http://www.cnblogs.com/chenwenbiao/archive/2012/06/06/2537508.html 

樂觀鎖介紹：

樂觀鎖（ Optimistic Locking ） 相對悲觀鎖而言，樂觀鎖假設認爲數據一般情況下不會造成衝突，所以在數據進行提交更新的時候，纔會正式對數據的衝突與否進行檢測，如果發現衝突了，則讓返回用戶錯誤的信息，讓用戶決定如何去做。那麼我們如何實現樂觀鎖呢，一般來說有以下2種方式：

1.使用數據版本（Version）記錄機制實現，這是樂觀鎖最常用的一種實現方式。何謂數據版本？即爲數據增加一個版本標識，一般是通過爲數據庫表增加一個數字類型的 “version” 字段來實現。當讀取數據時，將version字段的值一同讀出，數據每更新一次，對此version值加一。當我們提交更新的時候，判斷數據庫表對應記錄的當前版本信息與第一次取出來的version值進行比對，如果數據庫表當前版本號與第一次取出來的version值相等，則予以更新，否則認爲是過期數據。用下面的一張圖來說明：

如上圖所示，如果更新操作順序執行，則數據的版本（version）依次遞增，不會產生衝突。但是如果發生有不同的業務操作對同一版本的數據進行修改，那麼，先提交的操作（圖中B）會把數據version更新爲2，當A在B之後提交更新時發現數據的version已經被修改了，那麼A的更新操作會失敗。

 

2.樂觀鎖定的第二種實現方式和第一種差不多，同樣是在需要樂觀鎖控制的table中增加一個字段，名稱無所謂，字段類型使用時間戳（timestamp）, 和上面的version類似，也是在更新提交的時候檢查當前數據庫中數據的時間戳和自己更新前取到的時間戳進行對比，如果一致則OK，否則就是版本衝突。

 

使用舉例：以MySQL InnoDB爲例

還是拿之前的實例來舉：商品goods表中有一個字段status，status爲1代表商品未被下單，status爲2代表商品已經被下單，那麼我們對某個商品下單時必須確保該商品status爲1。假設商品的id爲1。

 

下單操作包括3步驟：

1.查詢出商品信息

select (status,status,version) from t_goods where id=#{id}

2.根據商品信息生成訂單

3.修改商品status爲2

update t_goods 

set status=2,version=version+1

where id=#{id} and version=#{version};

 

那麼爲了使用樂觀鎖，我們首先修改t_goods表，增加一個version字段，數據默認version值爲1。

t_goods表初始數據如下：

Sql代碼 

mysql> select * from t_goods;   
+----+--------+------+---------+   
| id | status | name | version |   
+----+--------+------+---------+   
|  1 |      1 | 道具 |       1 |   
|  2 |      2 | 裝備 |       2 |   
+----+--------+------+---------+   
2 rows in set  
  
mysql>  

1. [sql] view plain copy

 

1. mysql> select * from t_goods;  
   +----+--------+------+---------+  
   | id | status | name | version |  
   +----+--------+------+---------+  
   |  1 |      1 | 道具 |       1 |  
   |  2 |      2 | 裝備 |       2 |  
   +----+--------+------+---------+  
   2 rows in set  
     
   mysql>  

    

對於樂觀鎖的實現，我使用MyBatis來進行實踐，具體如下：

Goods實體類：

Java代碼 

1. /**  
    * ClassName: Goods <br/>  
    * Function: 商品實體. <br/>  
    * date: 2013-5-8 上午09:16:19 <br/>  
    * @author [email protected]  
    */  
   public class Goods implements Serializable {   
     
       /**  
        * serialVersionUID:序列化ID.  
        */  
       private static final long serialVersionUID = 6803791908148880587L;   
          
       /**  
        * id:主鍵id.  
        */  
       private int id;   
          
       /**  
        * status:商品狀態：1未下單、2已下單.  
        */  
       private int status;   
          
       /**  
        * name:商品名稱.  
        */  
       private String name;   
          
       /**  
        * version:商品數據版本號.  
        */  
       private int version;   
          
       @Override  
       public String toString(){   
           return "good id:"+id+",goods status:"+status+",goods name:"+name+",goods version:"+version;   
       }   
     
       //setter and getter   
     
   }  

    

GoodsDao

Java代碼 

1. /**  
    * updateGoodsUseCAS:使用CAS(Compare and set)更新商品信息. <br/>  
    *  
    * @author [email protected]  
    * @param goods 商品對象  
    * @return 影響的行數  
    */  
   int updateGoodsUseCAS(Goods goods);  

    

[java] view plain copy

 

1. /** 
    * updateGoodsUseCAS:使用CAS(Compare and set)更新商品信息. <br/> 
    * 
    * @author [email protected] 
    * @param goods 商品對象 
    * @return 影響的行數 
    */  
   int updateGoodsUseCAS(Goods goods);  

    

mapper.xml

Xml代碼 

1. <update id="updateGoodsUseCAS" parameterType="Goods">  
       <![CDATA[  
           update t_goods  
           set status=#{status},name=#{name},version=version+1  
           where id=#{id} and version=#{version}  
       ]]>  
   </update>  

    

[xml] view plain copy

 

1. <update id="updateGoodsUseCAS" parameterType="Goods">  
       <![CDATA[ 
           update t_goods 
           set status=#{status},name=#{name},version=version+1 
           where id=#{id} and version=#{version} 
       ]]>  
   </update>  

    

GoodsDaoTest測試類

Java代碼 

1. @Test  
   public void goodsDaoTest(){   
       int goodsId = 1;   
       //根據相同的id查詢出商品信息，賦給2個對象   
       Goods goods1 = this.goodsDao.getGoodsById(goodsId);   
       Goods goods2 = this.goodsDao.getGoodsById(goodsId);   
          
       //打印當前商品信息   
       System.out.println(goods1);   
       System.out.println(goods2);   
          
       //更新商品信息1   
       goods1.setStatus(2);//修改status爲2   
       int updateResult1 = this.goodsDao.updateGoodsUseCAS(goods1);   
       System.out.println("修改商品信息1"+(updateResult1==1?"成功":"失敗"));   
          
       //更新商品信息2   
       goods1.setStatus(2);//修改status爲2   
       int updateResult2 = this.goodsDao.updateGoodsUseCAS(goods1);   
       System.out.println("修改商品信息2"+(updateResult2==1?"成功":"失敗"));   
   }  

    

Shell代碼 

1. good id:1,goods status:1,goods name:道具,goods version:1  
   good id:1,goods status:1,goods name:道具,goods version:1  
   修改商品信息1成功   
   修改商品信息2失敗  

    

說明：

在GoodsDaoTest測試方法中，我們同時查出同一個版本的數據，賦給不同的goods對象，然後先修改good1對象然後執行更新操作，執行成功。然後我們修改goods2，執行更新操作時提示操作失敗。此時t_goods表中數據如下：

Sql代碼 

1. mysql> select * from t_goods;   
2. +----+--------+------+---------+   
3. | id | status | name | version |   
4. +----+--------+------+---------+   
5. |  1 |      2 | 道具 |       2 |   
6. |  2 |      2 | 裝備 |       2 |   
7. +----+--------+------+---------+   
8. 2 rows in set  
9.   
10. mysql>   

[sql] view plain copy

 

1. mysql> select * from t_goods;  
2. +----+--------+------+---------+  
3. | id | status | name | version |  
4. +----+--------+------+---------+  
5. |  1 |      2 | 道具 |       2 |  
6. |  2 |      2 | 裝備 |       2 |  
7. +----+--------+------+---------+  
8. 2 rows in set  
9.   
10. mysql>   

我們可以看到 id爲1的數據version已經在第一次更新時修改爲2了。所以我們更新good2時update where條件已經不匹配了，所以更新不會成功，具體sql如下：

Sql代碼 

1. update t_goods    
2. set status=2,version=version+1   
3. where id=#{id} and version=#{version};  

[sql] view plain copy

 

1. update t_goods   
2. set status=2,version=version+1  
3. where id=#{id} and version=#{version};  

這樣我們就實現了樂觀鎖