2. 程式人生 > >資料庫悲觀鎖和樂觀鎖使用Mybatis

資料庫悲觀鎖和樂觀鎖使用Mybatis

阿新 • • 發佈：2018-12-15

以下是轉載的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 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程式碼

    mysql> select * from t_goods;   
    +----+--------+------+   
    | id | status | name |   
    +----+--------+------+   
    |  1 |      1 | 道具 |   
    |  2 |      1 | 裝備 |   
    +----+--------+------+   
    2 rows in set  
      
    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程式碼

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

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

console2：查詢被阻塞

Sql程式碼 

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. 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. mysql> select * from t_goods where id>0 for update;   
  4. +----+--------+------+   
  5. | id | status | name |   
  6. +----+--------+------+   
  7. |  1 |      1 | 道具 |   
  8. |  2 |      1 | 裝備 |   
  9. +----+--------+------+   
  10. 2 rows in set  
  11. 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. mysql> select * from t_goods where id<>1 for update;   
  4. +----+--------+------+   
  5. | id | status | name |   
  6. +----+--------+------+   
  7. |  2 |      1 | 裝備 |   
  8. +----+--------+------+   
  9. 1 row in set  
  10. 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. 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. 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. 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. 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程式碼 複製程式碼

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

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

Goods實體類：

Java程式碼 複製程式碼

  1. /**  
  2.  * ClassName: Goods <br/>  
  3.  * Function: 商品實體. <br/>  
  4.  * date: 2013-5-8 上午09:16:19 <br/>  
  5.  * @author [email protected]  
  6.  */  
  7. public class Goods implements Serializable {   
  8.     /**  
  9.      * serialVersionUID:序列化ID.  
  10.      */  
  11.     private static final long serialVersionUID = 6803791908148880587L;   
  12.     /**  
  13.      * id:主鍵id.  
  14.      */  
  15.     private int id;   
  16.     /**  
  17.      * status:商品狀態：1未下單、2已下單.  
  18.      */  
  19.     private int status;   
  20.     /**  
  21.      * name:商品名稱.  
  22.      */  
  23.     private String name;   
  24.     /**  
  25.      * version:商品資料版本號.  
  26.      */  
  27.     private int version;   
  28.     @Override  
  29.     public String toString(){   
  30.         return "good id:"+id+",goods status:"+status+",goods name:"+name+",goods version:"+version;   
  31.     }   
  32.     //setter and getter   
  33. }  
  1. /** 
  2.  * ClassName: Goods <br/> 
  3.  * Function: 商品實體. <br/> 
  4.  * date: 2013-5-8 上午09:16:19 <br/> 
  5.  * @author [email protected] 
  6.  */  
  7. public class Goods implements Serializable {  
  8.     /** 
  9.      * serialVersionUID:序列化ID. 
  10.      */  
  11.     private static final long serialVersionUID = 6803791908148880587L;  
  12.     /** 
  13.      * id:主鍵id. 
  14.      */  
  15.     private int id;  
  16.     /** 
  17.      * status:商品狀態：1未下單、2已下單. 
  18.      */  
  19.     private int status;  
  20.     /** 
  21.      * name:商品名稱. 
  22.      */  
  23.     private String name;  
  24.     /** 
  25.      * version:商品資料版本號. 
  26.      */  
  27.     private int version;  
  28.     @Override  
  29.     public String toString(){  
  30.         return "good id:"+id+",goods status:"+status+",goods name:"+name+",goods version:"+version;  
  31.     }  
  32.     //setter and getter  
  33. }  

GoodsDao

Java程式碼 複製程式碼

  1. /**  
  2.  * updateGoodsUseCAS:使用CAS(Compare and set)更新商品資訊. <br/>  
  3.  *  
  4.  * @author [email protected]  
  5.  * @param goods 商品物件  
  6.  * @return 影響的行數  
  7.  */  
  8. int updateGoodsUseCAS(Goods goods);  
  1. /** 
  2.  * updateGoodsUseCAS:使用CAS(Compare and set)更新商品資訊. <br/> 
  3.  * 
  4.  * @author [email protected] 
  5.  * @param goods 商品物件 
  6.  * @return 影響的行數 
  7.  */  
  8. int updateGoodsUseCAS(Goods goods);  

mapper.xml

Xml程式碼 複製程式碼

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

GoodsDaoTest測試類

Java程式碼 複製程式碼

  1. @Test  
  2. public void goodsDaoTest(){   
  3.     int goodsId = 1;   
  4.     //根據相同的id查詢出商品資訊，賦給2個物件   
  5.     Goods goods1 = this.goodsDao.getGoodsById(goodsId);   
  6.     Goods goods2 = this.goodsDao.getGoodsById(goodsId);   
  7.     //列印當前商品資訊   
  8.     System.out.println(goods1);   
  9.     System.out.println(goods2);   
  10.     //更新商品資訊1   
  11.     goods1.setStatus(2);//修改status為2   
  12.     int updateResult1 = this.goodsDao.updateGoodsUseCAS(goods1);   
  13.     System.out.println("修改商品資訊1"+(updateResult1==1?"成功":"失敗"));   
  14.     //更新商品資訊2   
  15.     goods1.setStatus(2);//修改status為2   
  16.     int updateResult2 = this.goodsDao.updateGoodsUseCAS(goods1);   
  17.     System.out.println("修改商品資訊2"+(updateResult2==1?"成功":"失敗"));   
  18. }  
  1. @Test  
  2. public void goodsDaoTest(){  
  3.     int goodsId = 1;  
  4.     //根據相同的id查詢出商品資訊，賦給2個物件  
  5.     Goods goods1 = this.goodsDao.getGoodsById(goodsId);  
  6.     Goods goods2 = this.goodsDao.getGoodsById(goodsId);  
  7.     //列印當前商品資訊  
  8.     System.out.println(goods1);  
  9.     System.out.println(goods2);  
  10.     //更新商品資訊1  
  11.     goods1.setStatus(2);//修改status為2  
  12.     int updateResult1 = this.goodsDao.updateGoodsUseCAS(goods1);  
  13.     System.out.println("修改商品資訊1"+(updateResult1==1?"成功":"失敗"));  
  14.     //更新商品資訊2  
  15.     goods1.setStatus(2);//修改status為2  
  16.     int updateResult2 = this.goodsDao.updateGoodsUseCAS(goods1);  
  17.     System.out.println("修改商品資訊2"+(updateResult2==1?"成功":"失敗"));  
  18. }  

輸出結果：

Shell程式碼 複製程式碼

  1. good id:1,goods status:1,goods name:道具,goods version:1  
  2. good id:1,goods status:1,goods name:道具,goods version:1  
  3. 修改商品資訊1成功   
  4. 修改商品資訊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. mysql>   
  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. 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};  
  1. update t_goods   
  2. set status=2,version=version+1  
  3. where id=#{id} and version=#{version};  

這樣我們就實現了樂觀鎖

相關推薦

資料庫悲觀鎖和樂觀鎖使用Mybatis

以下是轉載的oracle和Mysql兩種資料庫悲觀鎖和樂觀鎖機制及樂觀鎖實現方式： 一、Oracle Oracle資料庫悲觀鎖與樂觀鎖是本文我們主要要介紹的內容。有時候為了得到最大的效能，一般資料庫都有併發機制，不過帶來的問題就是資料訪問的衝突。為了解決這個問題，大多數資

深入瞭解和探索資料庫的悲觀鎖和樂觀鎖

 在資料庫的鎖機制中介紹過，資料庫管理系統（DBMS）中的併發控制的任務是確保在多個事務同時存取資料庫中同一資料時不破壞事務的隔離性和統一性以及資料庫的統一性。 樂觀併發控制(樂觀鎖)和悲觀併發控制（悲觀鎖）是併發控制主要採用的技術手段。 無論是悲觀鎖還是樂觀鎖，都是人們定義出來

資料庫的悲觀鎖和樂觀鎖

一 ：悲觀鎖（Pessimistic Locking）  悲觀鎖，正如其名，它指的是對資料被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度，因此，在整個資料處理過程中，將資料處於鎖定 狀態。悲觀鎖的實現，往往依靠資料庫提供的鎖機制（也只有資料庫層提

資料庫的隔離級別以及悲觀鎖和樂觀鎖詳解

一、事務四大屬性 分別是原子性、一致性、隔離性、永續性。 1、原子性（Atomicity） 原子性是指事務包含的所有操作要麼全部成功，要麼全部失敗回滾，因此事務的操作如果成功就必須要完全應用到資料庫，如果操作失敗則不能對資料庫有任何影響。 2、一

MySQL數據庫同步之悲觀鎖和樂觀鎖

我們 測試 http 鎖定 以及 再次 否則 即使 name 測試需要：本地開兩個測試窗口 悲觀鎖 悲觀鎖它指的是對數據被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度，在整個數據處理過程中，將數據處於鎖定狀態。悲觀鎖的實現，往往依靠數據庫提供的

悲觀鎖和樂觀鎖

mysql鎖有兩種機制：悲觀鎖和樂觀鎖。悲觀鎖 悲觀鎖，鎖如其名，他對世界是悲觀的，他認為別人訪問正在改變的數據的概率是很高的，所以從數據開始更改時就將數據鎖住，直到更改完成才釋放。一個典型的倚賴數據庫的悲觀鎖調用： select * from account where name=”Erica”

Hibernate 再接觸 悲觀鎖和樂觀鎖

package his sts nsa comm pen hibernate UNC ann 為什麽取1248 二進制 CRUD 移位效率高 在並發和效率選擇一個平衡點 一般不會考慮幻讀 因為我們不會再一個事務裏查詢兩次，（只能設置為seralizable） 悲觀鎖

hibernate鎖機制有什麼用？Hibernate的悲觀鎖和樂觀鎖機制

有些業務邏輯在執行過程中要求對資料進行排他性的訪問，於是需要通過一些機制保證在此過程中資料被鎖住不會被外界修改，這就是所謂的鎖機制。 Hibernate支援悲觀鎖和樂觀鎖兩種鎖機制。悲觀鎖，顧名思義悲觀的認為在資料處理過程中極有可能存在修改資料的併發事務（包括本系統的其他事務或來自外部系統的

悲觀鎖和樂觀鎖的簡單瞭解

悲觀鎖：悲觀鎖是由資料庫提供的，用於防止資料庫併發控制造成的異常。 　　實現悲觀鎖：在要進行加鎖的事務中的sql語句末加上 for update。 　　悲觀鎖正如他的名字一樣，比較悲觀，他在加鎖過程中，不允許任何事務進行查詢或增刪改。       樂觀鎖：樂觀鎖是由邏

java多執行緒系列3：悲觀鎖和樂觀鎖

1.悲觀鎖和樂觀鎖的基本概念 悲觀鎖： 總是認為當前想要獲取的資源存在競爭(很悲觀的想法)，因此獲取資源後會立刻加鎖，於是其他執行緒想要獲取該資源的時候就會一直阻塞直到能夠獲取到鎖； 在傳統的關係型資料庫中，例如行鎖、表鎖、讀鎖、寫鎖等，都用到了悲觀鎖。還有java中的同步關鍵字Synchroniz

hibernate面試題之鎖機制有什麼用？簡述Hibernate的悲觀鎖和樂觀鎖機制

有些業務邏輯在執行過程中要求對資料進行排他性的訪問，於是需要通過一些機制保證在此過程中資料被鎖住不會被外界修改，這就是所謂的鎖機制。 Hibernate支援悲觀鎖和樂觀鎖兩種鎖機制。悲觀鎖，顧名思義悲觀的認為在資料處理過程中極有可能存在修改資料的併發事務（包括本

synchronized和lock的區別；悲觀鎖和樂觀鎖的區別

synchronized和lock的區別：  1.用法不一樣。synchronized既可以加在方法上，也可以載入特定的程式碼塊上，括號中表示需要鎖的物件。而Lock需要顯示地指定起始位置和終止位置。synchronzied是託管給jvm執行的，Lock鎖定是通過程式碼實現

Spring Boot+SQL/JPA實戰悲觀鎖和樂觀鎖

最近在公司的業務上遇到了併發的問題，並且還是很常見的併發問題，算是低階的失誤了。由於公司業務相對比較複雜且不適合公開，在此用一個很常見的業務來還原一下場景，同時介紹悲觀鎖和樂觀鎖是如何解決這類併發問題的。 公司業務就是最常見的“訂單+賬戶”問題，在解決完公司問題後，轉頭一想，我的部落格專案Fame中也有同樣

mysql悲觀鎖和樂觀鎖

一、悲觀鎖 1、排它鎖，當事務在操作資料時把這部分資料進行鎖定，直到操作完畢後再解鎖，其他事務操作才可操作該部分資料。這將防止其他程序讀取或修改表中的資料。 2、實現：大多數情況下依靠資料庫的鎖機制實現 一般使用 select ...for update

悲觀鎖和樂觀鎖解決事務丟失跟新問題

事務丟失更新：A，B兩個事務通過id獲取資料，name：lisi，money：1000 首先，A事務修改name，把lisi變為zhangsan，然後提交事務。此時，B事務中不受A事務的影響，即B事務中的name還是lisi，此時如果B事務改變money為2000，然後提交事務。最後資料庫的資料

redis的 悲觀鎖和樂觀鎖的區別

悲觀鎖(Pessimistic Lock), 顧名思義，就是很悲觀，每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會block直到它拿到鎖。傳統的關係型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作

Java鎖機制 悲觀鎖和樂觀鎖

鎖的存在，是為了解決在併發環境下，資料的一致性問題。鎖機制保證了程式不會出現，髒讀，衝突等情況。 先介紹下，悲觀鎖和樂觀鎖的基本描述。 悲觀鎖 正如其名，當出現在多使用者的併發環境中時， 它對資料出現併發衝突，持保守態度（悲觀）。它假定一定出現衝突，所以在

悲觀鎖和樂觀鎖的區別及應用場景

資料的鎖定分為兩種，第一種叫作悲觀鎖，第二種叫作樂觀鎖。 1、悲觀鎖，就是對資料的衝突採取一種悲觀的態度，也就是說假設資料肯定會衝突，所以在資料開始讀取的時候就把資料鎖定住。【資料鎖定：資料將暫時不會得到修改】 2、樂觀鎖，認為資料一般情況下不會造成衝突，所以在資料進行提交

小議“悲觀鎖和樂觀鎖”的原理、場景、示例

[1] 博由 前幾天與一些朋友談到這個問題，之前有一些概念的上的涉及，但是並沒有相對深入的瞭解，因此找一些資料來幫助自己理解悲觀鎖和樂觀鎖的概念理解、場景、然後通過示例來闡述樂觀鎖和悲觀鎖的實現方式。 [2] 摘要 本文將從三個方面來闡

悲觀鎖和樂觀鎖的區別和應用場景

悲觀鎖(Pessimistic Lock), 顧名思義，就是很悲觀，每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會block直到它拿到鎖。傳統的關係型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操