2. 程式人生 > >悲觀鎖樂觀鎖實戰

悲觀鎖樂觀鎖實戰

阿新 • • 發佈：2018-03-25
查看 ring 加鎖 starting 讀取 並不是 ava 情況下 有一個

悲觀鎖介紹（百科）：

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

使用場景舉例：以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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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
  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悲觀鎖，但是悲觀鎖並不是適用於任何場景，它也有它存在的一些不足，因為悲觀鎖大多數情況下依靠數據庫的鎖機制實現，以保證操作最大程度的獨占性。如果加鎖的時間過長，其他用戶長時間無法訪問，影響了程序的並發訪問性，同時這樣對數據庫性能開銷影響也很大，特別是對長事務而言，這樣的開銷往往無法承受。所以與悲觀鎖相對的，我們有了樂觀鎖，具體參見下面介紹：

樂觀鎖介紹：

樂觀鎖（ 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
  10. mysql>
[sql] view plain copy
  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
  10. 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 {
  9. /**
  10. * serialVersionUID:序列化ID.
  11. */
  12. private static final long serialVersionUID = 6803791908148880587L;
  14. /**
  15. * id:主鍵id.
  16. */
  17. private int id;
  19. /**
  20. * status:商品狀態：1未下單、2已下單.
  21. */
  22. private int status;
  24. /**
  25. * name:商品名稱.
  26. */
  27. private String name;
  29. /**
  30. * version:商品數據版本號.
  31. */
  32. private int version;
  34. @Override
  35. public String toString(){
  36. return "good id:"+id+",goods status:"+status+",goods name:"+name+",goods version:"+version;
  37. }
  39. //setter and getter
  41. }
[java] view plain copy
  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 {
  9. /**
  10. * serialVersionUID:序列化ID.
  11. */
  12. private static final long serialVersionUID = 6803791908148880587L;
  14. /**
  15. * id:主鍵id.
  16. */
  17. private int id;
  19. /**
  20. * status:商品狀態：1未下單、2已下單.
  21. */
  22. private int status;
  24. /**
  25. * name:商品名稱.
  26. */
  27. private String name;
  29. /**
  30. * version:商品數據版本號.
  31. */
  32. private int version;
  34. @Override
  35. public String toString(){
  36. return "good id:"+id+",goods status:"+status+",goods name:"+name+",goods version:"+version;
  37. }
  39. //setter and getter
  41. }

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);
[java] view plain copy
  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>
[xml] view plain copy
  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);
  8. //打印當前商品信息
  9. System.out.println(goods1);
  10. System.out.println(goods2);
  12. //更新商品信息1
  13. goods1.setStatus(2);//修改status為2
  14. int updateResult1 = this.goodsDao.updateGoodsUseCAS(goods1);
  15. System.out.println("修改商品信息1"+(updateResult1==1?"成功":"失敗"));
  17. //更新商品信息2
  18. goods1.setStatus(2);//修改status為2
  19. int updateResult2 = this.goodsDao.updateGoodsUseCAS(goods1);
  20. System.out.println("修改商品信息2"+(updateResult2==1?"成功":"失敗"));
  21. }
[java] view plain copy
  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);
  8. //打印當前商品信息
  9. System.out.println(goods1);
  10. System.out.println(goods2);
  12. //更新商品信息1
  13. goods1.setStatus(2);//修改status為2
  14. int updateResult1 = this.goodsDao.updateGoodsUseCAS(goods1);
  15. System.out.println("修改商品信息1"+(updateResult1==1?"成功":"失敗"));
  17. //更新商品信息2
  18. goods1.setStatus(2);//修改status為2
  19. int updateResult2 = this.goodsDao.updateGoodsUseCAS(goods1);
  20. System.out.println("修改商品信息2"+(updateResult2==1?"成功":"失敗"));
  21. }

輸出結果：

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

這樣我們就實現了樂觀鎖

參考資料：

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

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

悲觀鎖樂觀鎖實戰

相關推薦

悲觀鎖樂觀鎖實戰

查看 ring 加鎖 starting 讀取 並不是 ava 情況下 有一個 悲觀鎖介紹（百科）： 悲觀鎖，正如其名，它指的是對數據被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度，因此，在整個數據處理過程中，將數據處於鎖定狀態。悲觀鎖的實現，往

談談mysql的悲觀和樂觀鎖

更新失敗 自動 結束 lan 版本號 得到 例如 中一 其他 悲觀鎖與樂觀鎖是兩種常見的資源並發鎖設計思路，也是並發編程中一個非常基礎的概念。之前有寫過一篇文章關於並發的處理思路和解決方案，這裏我單獨將對這兩種常見的鎖機制在數據庫數據上的實現進行比較系統的介紹一次吧。 悲觀

悲觀鎖樂觀鎖簡單整理

處理 業務邏輯 失敗 問題： 多個 處理過程 覆蓋 解決 控制 一：介紹 悲觀鎖，正如其名，具有強烈的獨占和排他特性。它指的是對數據被外界（包括本系統當前的其他事務，以及來自外部系統的事務處理）修改持保守態度，因此，在整個數據處理過程中，將數據處於鎖定狀態。悲觀鎖的實現，往

CAS無鎖演算法：ReentrantLock，synchronized(JDK 1.6)，悲觀鎖/樂觀鎖

> 悲觀鎖/樂觀鎖  悲觀鎖：總是假設最壞的情況，每次去拿資料的時候都認為別人會修改，所以每次在拿資料的時候都會上鎖，這樣別人想拿這個資料就會阻塞直到它拿到鎖。傳統的關係型資料庫裡邊就用到了很多這種鎖機制，比如行鎖，表鎖等，讀鎖，寫鎖等，都是在做操作之前先上鎖。再比如J

事務 鎖 悲觀鎖 樂觀鎖 概念 應用場景 使用方式 小記

【部落格園cnblogs筆者m-yb原創(部分引用, 在文末有註明)，轉載請加本文部落格連結，筆者github: https://github.com/mayangbo666，公眾號aandb7，QQ群927113708】  https://www.cnblogs.com/m-yb/p/99749

Java併發 行級鎖/欄位鎖/表級鎖 樂觀鎖/悲觀鎖 共享鎖/排他鎖 死鎖[轉]

前言 鎖是防止在兩個事務操作同一個資料來源（表或行）時互動破壞資料的一種機制。 資料庫採用封鎖技術保證併發操作的可序列性。 以Oracle為例： Oracle的鎖分為兩大類：資料鎖（也稱DML鎖）和字典鎖。 字典鎖是Oracle DBMS內部用於對字典表的封鎖。 字典鎖包括語

MySQL資料庫優化（三）——MySQL悲觀鎖&&樂觀鎖（併發控制）

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

Redis 事物、悲觀、樂觀鎖 (詳細)

  1，概論 　　　　　　事物這東西相信大家都不陌生吧,在學習Spring,Mybatis等框架中, 　　　　　　只要是涉及到資料儲存和修改的,都會有事物的存在， 　　　　　　廢話就不多說了下面我們來簡單的介紹下Redis事物以及鎖。 2，Redis事物簡介？ 　　  Re

mysql的悲觀和樂觀鎖分析

我們在操作資料庫的時候，可能會由於併發問題而引起的資料的不一致性（資料衝突），這個時候就有了鎖！！！ 樂觀鎖顧明思議，想法很樂觀，在更新資料時，認為這波操作不會導致衝突，別的sql也不會對此操作進行更改，所以我線更新資料，等待提交的時候再去判斷是否衝突。 樂觀鎖需要我們自己去實現，資料庫設計上，

獨享鎖/共享鎖+公平鎖/非公平鎖+樂觀鎖/悲觀鎖

本文標題：最全Java鎖詳解：獨享鎖/共享鎖+公平鎖/非公平鎖+樂觀鎖/悲觀鎖  轉載請保留頁面地址：http://youzhixueyuan.com/detailed-explanation-of-java-lock.html 在Java併發場景中，會涉及到各種各樣的鎖如公平鎖，樂觀

最全Java鎖詳解：獨享鎖/共享鎖+公平鎖/非公平鎖+樂觀鎖/悲觀鎖

最全Java鎖詳解：獨享鎖/共享鎖+公平鎖/非公平鎖+樂觀鎖/悲觀鎖 樂觀鎖 VS 悲觀鎖 1.樂觀鎖 2.悲觀鎖 3.總之 公平鎖 VS 非公平鎖 1.公平鎖 2.非公平鎖 3.典型應用

Hibernate悲觀鎖/樂觀鎖

如果需要保證資料訪問的排它性，則需對目標資料加“鎖”，使其無法被其它程式修改 一，悲觀鎖 對資料被外界（包括本系統當前的其它事務和來自外部系統的事務處理）修改持保守態度，通過資料庫提供的鎖機制實現 最常用的，是對查詢進行加鎖（LockMode.UPGRADE和LockMod

Hibernate--悲觀鎖&樂觀鎖

悲觀鎖：    悲觀鎖假定當多個事務同時訪問一個資源時，會出現併發問題。因而為了避免這些問題，悲觀鎖假定當多個事務在操作一個資源時，都先把該資源鎖起來，這樣就完全排除了當前事務受其他事務的影響。但是使用悲觀鎖影響併發效能，所以應該謹慎。使用悲觀鎖：    在Hibernate

Hibernate中悲觀鎖樂觀鎖的應用

一個典型的倚賴資料庫的悲觀鎖呼叫： select * from account where name=”Erica” for update 這條sql 語句鎖定了account 表中所有符合檢索條（name=”Erica”）的記錄。本次事務提交之前（事務

淺談Oracle鎖機制表鎖行鎖樂觀鎖悲觀鎖

　　Oracle的鎖機制主要分為行鎖和表鎖，行鎖即鎖定表中的某行資料，表鎖鎖定表中所有資料。鎖定的資料不能插入，更新，刪除，只能查詢，語法 for update。鎖的週期為一次資料提交，一次資料提交中可能會有多條SQL語句。 　　在大併發中為了保證某些資料的唯

Hibernate JPA 悲觀鎖,樂觀鎖

1.悲觀鎖 它指的是對資料被外界修改持保守態度。假定任何時刻存取資料時，都可能有另一個客戶也正在存取同一筆資料，為了保持資料被操作的一致性，於是對資料採取了資料庫層次的鎖定狀態，依靠資料庫提供的鎖機制來實現。 基於jdbc實現的資料庫加鎖如下： selec

關於高併發 悲觀鎖 樂觀鎖

1、考慮高併發，若不加鎖，操作同一條資料會出現後一次更改覆蓋前一次提交的資料，資料丟失； 2、加鎖分為樂觀鎖、悲觀鎖：       在hibernate情景下：                                         悲觀鎖的使用-----query

【MySQL】悲觀鎖&樂觀鎖

悲觀鎖與樂觀鎖是兩種常見的資源併發鎖設計思路，也是併發程式設計中一個非常基礎的概念。本文將對這兩種常見的鎖機制在資料庫資料上的實現進行比較系統的介紹。 悲觀鎖（Pessimistic Lock） 悲觀鎖的特點是先獲取鎖，再進行業務操作，即“悲觀”的認為獲取鎖是非常

StampedLock悲觀鎖樂觀鎖

StampedLock java1.8提供的, 效能比ReadWriteLock好. 語法 final StampedLock

Redis分散式鎖----樂觀鎖的實現，以秒殺系統為例

     摘要：本文使用redis來實現樂觀鎖，並以秒殺系統為例項來講解整個過程。 樂觀鎖       大多數是基於資料版本（version）的記錄機制實現的。即為資料增加一個版本標識，在基於資料庫表的版本解決方案中，一般是通過為資料庫表增加一個”version”欄位來