MySql事務隔離級別

在講mysql事物隔離級別以前，咱們先簡單說說mysql的鎖和事務。

一：數據庫鎖

由於數據庫要解決併發控制問題。在同一時刻，可能會有多個客戶端對同一張表進行操做，好比有的在讀取該行數據，其餘的嘗試去刪除它。爲了保證數據的一致性，數據庫就要對這種併發操做進行控制，所以就有了鎖的概念。

鎖的分類

從對數據庫操做的類型分

讀鎖（共享鎖）：針對同一塊數據，多個讀操做能夠同時進行而不會互相影響。由讀表操做加上的鎖，加鎖後其餘用戶只能獲取該表或行的共享鎖，不能獲取排它鎖，也就是說只能讀不能寫。

寫鎖（排它鎖）：噹噹前寫操做沒有完成以前，它會阻斷其餘寫鎖和讀鎖。由寫表操做加上的鎖，加鎖後其餘用戶不能獲取該表或行的任何鎖。

從鎖定的數據範圍分

表鎖：鎖定某個表。

行鎖 ：鎖定某行。

爲了儘量 提升數據庫的併發度，每次鎖定的數據範圍越小越好。理論上每次只鎖定當前操做的數據的方案會獲得最大的併發度，可是管理鎖是很耗費資源的事情。所以數據庫系統須要在高併發響應和系統性能兩方面進行平衡，這樣就產生了「鎖粒度」的概念。

鎖粒度

表鎖：管理鎖的開銷最小，同時容許的併發量也最小的鎖機制。MyIsam存儲引擎使用的鎖機制。當要寫入數據時，把整個表都鎖上，此時其餘讀、寫動做一概等待。在MySql中，除了MyIsam存儲引擎使用這種鎖策略外，MySql自己也使用表鎖來執行某些特定動做，好比alter table.

行鎖：能夠支持最大併發的鎖策略。InnoDB和Falcon兩張存儲引擎都採用這種策略。

MySql是一種開放的架構，你能夠實現本身的存儲引擎，並實現本身的鎖粒度策略，不像Oracle，你沒有機會改變鎖策略，Oracle採用的是行鎖。從大到小，mysql服務器僅支持表級鎖，行鎖須要存儲引擎完成。粒度越精細，併發性越好。即行鎖的併發性最好，但須要存儲引擎的支持。

二：事務

從業務角度出發 ，對數據庫的一組操做要求保持4個特徵：

Atomicity：原子性。

Consistency：一致性。

Isolation：隔離性。

Durability：持久性。

爲了更好地理解ACID，以銀行帳戶轉帳爲例： 

1 START TRANSACTION;

2 SELECT balance FROM checking WHERE customer_id = 10233276;

3 UPDATE checking SET balance = balance - 200.00 WHERE customer_id = 10233276;

4 UPDATE savings SET balance = balance + 200.00 WHERE customer_id = 10233276;

5 COMMIT;

原子性：要麼徹底提交（10233276的checking餘額減小200，savings 的餘額增長200），要麼徹底回滾（兩個表的餘額都不發生變化）。

一致性：這個例子的一致性體如今 200元不會由於數據庫系統運行到第3行以後，第4行以前時崩潰而不知去向，由於事物尚未提交。 

隔離性：容許在一個事務中的操做語句會與其餘事務的語句隔離開，好比事務A運行到第3行以後，第4行以前，此時事務B去查詢checking餘額時，它仍然可以看到在事務A中被減去的200元，由於事務A和B是彼此隔離的。在事務A提交以前，事務B觀察不到數據的改變。

持久性：這個很好理解。

事務跟鎖同樣都會須要大量工做，所以你能夠根據你本身的須要來決定是否須要事務支持，從而選擇不一樣的存儲引擎。 

三：事務隔離級別

SQL標準定義了4中隔離級別，包括了一些具體規則，用來限定事務內外的哪些改變是可見的，哪些是不可見的。低級別的隔離級通常支持更高的併發處理，並擁有更低的系統開銷。

Read Uncommitted（讀取未提交內容） 

在該隔離級別，全部事務均可以看到其餘未提交事務的執行結果。本隔離級別不多用於實際應用，由於它的性能也不比其餘級別好多少。讀取未提交的數據，也被稱之爲髒讀（Dirty Read）。  

Read Committed（讀取提交內容）

這是大多數數據庫系統的默認隔離級別（但不是MySQL默認的）。它知足了隔離的簡單定義：一個事務只能看見已經提交事務所作的改變。這種隔離級別 也支持所謂的不可重複讀（Nonrepeatable Read），由於同一事務的其餘實例在該實例處理其間可能會有新的commit，因此同一select可能返回不一樣結果。 

Repeatable Read（可重讀）

這是MySQL的默認事務隔離級別，它確保同一事務的多個實例在併發讀取數據時，會看到一樣的數據行。 不過理論上，這會致使另外一個棘手的問題：幻讀 （Phantom Read）。簡單的說，幻讀指當用戶讀取某一範圍的數據行時， 另外一個事務又在該範圍內插入了新行，當用戶再讀取該範圍的數據行時，會發現有新的「幻影」 行。 InnoDB和Falcon存儲引擎經過多版本併發控制（MVCC，Multiversion Concurrency Control）機制解決了該問題。 

Serializable（可串行化）  

這是最高的隔離級別，它經過強制事務排序，使之不可能相互衝突，從而解決幻讀問題。簡言之，它是在每一個讀的數據行上加上共享鎖。在這個級別，可能致使大量的超時現象和鎖競爭。

 這四種隔離級別採起不一樣的鎖類型來實現，若讀取的是同一個數據的話，就容易發生問題。例如：

髒讀(Drity Read)：某個事務已更新一份數據，另外一個事務在此時讀取了同一份數據，因爲某些緣由，前一個RollBack了操做，則後一個事務所讀取的數據就會是不正確的。

幻讀(Phantom Read):在一個事務的兩次查詢中數據筆數不一致，例若有一個事務查詢了幾列(Row)數據，而另外一個事務卻在此時插入了新的幾列數據，先前的事務在接下來的查詢中，就會發現有幾列數據是它先前所沒有的。

不可重複讀(Non-repeatable read):在一個事務的兩次查詢之中數據不一致，這多是兩次查詢過程當中間插入了一個事務更新的原有的數據。

案例：

Read Uncommitted（讀取未提交內容） 

在該隔離級別，全部事務均可以看到其餘未提交事務的執行結果。本隔離級別不多用於實際應用，由於它的性能也不比其餘級別好多少。讀取未提交的數據，也被稱之爲髒讀（Dirty Read）。

1.分別在A、B兩個客戶端執行： 

 

2. 
3. A： 
4. root@(none) 10:54>SET GLOBAL tx_isolation='READ-UNCOMMITTED';
5. Query OK, 0 rows affected (0.00 sec)
6. 
7. root@(none) 10:54>SELECT @@tx_isolation;
8. +------------------+
9. | @@tx_isolation |
10. +------------------+
11. | READ-UNCOMMITTED |
12. +------------------+
13. 1 row in set (0.00 sec)
14. 
15. root@(none) 10:54>use test;
16. Database changed
17. root@test 10:55>begin;
18. Query OK, 0 rows affected (0.00 sec)
19. 
20. root@test 10:55>select * from test1;
21. +------+
22. | a |
23. +------+
24. | 1 |
25. | 2 |
26. | 3 |
27. | 4 |
28. +------+
29. 4 rows in set (0.00 sec)
30. 
31. B上： 
32. root@test 10:58>select @@tx_isolation;
33. +------------------+
34. | @@tx_isolation |
35. +------------------+
36. | READ-UNCOMMITTED |
37. +------------------+
38. 1 row in set (0.00 sec)
39. 
40. root@test 10:58>
41. root@test 10:58>begin;
42. Query OK, 0 rows affected (0.00 sec)
43. 
44. root@test 10:58>insert into test.test1 values (999);
45. Query OK, 1 row affected (0.00 sec)
46. 
47. root@test 10:58>select * from test.test1;
48. +------+
49. | a |
50. +------+
51. | 1 |
52. | 2 |
53. | 3 |
54. | 4 |
55. | 999 |
56. +------+
57. 5 rows in set (0.00 sec)
58. 此處B客戶端並未commit；
59. 
60. 再查看A客戶端： 
61. root@test 10:58>select * from test1;
62. +------+
63. | a |
64. +------+
65. | 1 |
66. | 2 |
67. | 3 |
68. | 4 |
69. | 999 |
70. +------+
71. 5 rows in set (0.00 sec)
72. 

 

73. 此處A能夠看到新的記錄了。  

Read Committed（讀取提交內容）

這是大多數數據庫系統的默認隔離級別（但不是MySQL默認的）。它知足了隔離的簡單定義：一個事務只能看見已經提交事務所作的改變。 這種隔離級別 也支持所謂的不可重複讀（Nonrepeatable Read），由於同一事務的其餘實例在該實例處理其間可能會有新的commit，因此同一select可能返回不一樣結果。 

1.在A客戶端：

 

2. root@(none) 11:10>SET GLOBAL tx_isolation='READ-COMMITTED';
3. Query OK, 0 rows affected (0.00 sec)
4. 
5. root@(none) 11:10>SELECT @@tx_isolation;
6. +----------------+
7. | @@tx_isolation |
8. +----------------+
9. | READ-COMMITTED |
10. +----------------+
11. 1 row in set (0.00 sec)
12. 
13. root@(none) 11:10>
14. root@(none) 11:10>begin;
15. Query OK, 0 rows affected (0.00 sec)
16. 
17. root@(none) 11:10>select * from test.test1;
18. +------+
19. | a |
20. +------+
21. | 1 |
22. | 2 |
23. | 3 |
24. | 4 |
25. +------+
26. 
27. 在B客戶端執行：
28. root@test 11:11>begin;
29. Query OK, 0 rows affected (0.00 sec)
30. 
31. root@test 11:11>select * from test.test1;
32. +------+
33. | a |
34. +------+
35. | 1 |
36. | 2 |
37. | 3 |
38. | 4 |
39. +------+
40. 4 rows in set (0.00 sec)
41. 
42. root@test 11:11>
43. root@test 11:11>delete from test.test1 where a=1;
44. Query OK, 1 row affected (0.00 sec)
45. 
46. root@test 11:12>select * from test.test1;
47. +------+
48. | a |
49. +------+
50. | 2 |
51. | 3 |
52. | 4 |
53. +------+
54. 
55. 此時查詢A客戶端：
56. 
57. root@(none) 11:12>select * from test.test1;
58. +------+
59. | a |
60. +------+
61. | 1 |
62. | 2 |
63. | 3 |
64. | 4 |
65. +------+
66. 此處看出A客戶端無變化，在B客戶端執行commit後再查看A客戶端：
67. 
68. root@(none) 11:13>select * from test.test1;
69. +------+
70. | a |
71. +------+
72. | 2 |
73. | 3 |
74. | 4 |
75. +------+
76. 
77. 能夠看到A客戶端的數據已經變了。已提交讀只容許讀取已提交的記錄，但不要求可重複讀。
78. 用MVCC來講就是讀取當前行的最新版本。 

 

 Repeatable Read（可重讀）

這是MySQL的默認事務隔離級別，它確保同一事務的多個實例在併發讀取數據時，會看到一樣的數據行。 不過理論上，這會致使另外一個棘手的問題：幻讀 （Phantom Read）。 簡單的說，幻讀指當用戶讀取某一範圍的數據行時，另外一個事務又在該範圍內插入了新行，當用戶再讀取該範圍的數據行時，會發現有新的「幻影」 行。 InnoDB和Falcon存儲引擎經過多版本併發控制（MVCC，Multiversion Concurrency Control）機制解決了該問題。 

1.在A客戶端上：

 

2. root@(none) 11:17>SET GLOBAL tx_isolation='REPEATABLE-READ';
3. Query OK, 0 rows affected (0.00 sec)
4. 
5. root@(none) 11:17>
6. root@(none) 11:17>
7. root@(none) 11:17>SELECT @@tx_isolation;
8. +-----------------+
9. | @@tx_isolation |
10. +-----------------+
11. | REPEATABLE-READ |
12. +-----------------+
13. 1 row in set (0.00 sec)
14. 
15. root@(none) 11:17>BEGIN;
16. Query OK, 0 rows affected (0.00 sec)
17. 
18. 在B客戶端上：
19. root@test 11:20>select @@tx_isolation;
20. +-----------------+
21. | @@tx_isolation |
22. +-----------------+
23. | REPEATABLE-READ |
24. +-----------------+
25. 1 row in set (0.00 sec)
26. 
27. root@test 11:20>insert into test.test1 values (555);
28. Query OK, 1 row affected (0.00 sec)
29. 
30. root@test 11:20>commit;
31. Query OK, 0 rows affected (0.00 sec)
32. 
33. root@test 11:21>
34. root@test 11:21>select * from test.test1;
35. +------+
36. | a |
37. +------+
38. | 2 |
39. | 3 |
40. | 4 |
41. | 555 |
42. +------+
43. 4 rows in set (0.00 sec)
44. 此處在B客戶端上已經commit.
45. 
46. 而後查看A客戶端：
47. 
48. root@(none) 11:22>SELECT * FROM test.test1;
49. +------+
50. | a |
51. +------+
52. | 2 |
53. | 3 |
54. | 4 |
55. +------+
56. 3 rows in set (0.00 sec)
57. 
58. root@(none) 11:22>commit;
59. Query OK, 0 rows affected (0.00 sec)
60. 
61. 
62. root@(none) 11:22>SELECT * FROM test.test1;
63. +------+
64. | a |
65. +------+
66. | 2 |
67. | 3 |
68. | 4 |
69. | 555 |
70. +------+
71. 4 rows in set (0.00 sec)
72. 
73. 在A客戶端上提交後能夠看到新數據。
74. 也就是說在可重複讀隔離級別只能讀取已經提交的數據，而且在一個事務內，讀取的數據就是事務開始時的數據。 

 

 Serializable（可串行化）

這是最高的隔離級別，它經過強制事務排序，使之不可能相互衝突，從而解決幻讀問題。簡言之，它是在每一個讀的數據行上加上共享鎖。在這個級別，可能致使大量的超時現象和鎖競爭。 

該類型在A客戶端操做test.test1表時會鎖定該數據，若是B客戶端想要操做test.test1就須要等待A客戶端釋放。 

https://blog.csdn.net/weixin_40255793/article/details/79735665