MySQL 原理篇

MVCC

MVCC 的定義

MVCC（Multiversion concurrency control）：多版本併發控制，併發訪問（讀或寫）數據庫時，對正在事務內處理的數據做多版本的管理。以達到用來避免寫操作的堵塞，從而引發讀操作的併發問題。

MVCC 邏輯流程

插入

MySQL 在每一行數據中都會默認添加一些隱藏列 DB_TRX_ID、DB_ROLL_PT。

上面圖中的執行步驟如下：

1. 手動開啟事務，從 InnoDB 引擎中獲取一個全局事務ID（1）
2. 然後往 teacher 表中插入兩條數據，同時設置數據行的版本號為當前事務ID，刪除版本號為 NULL

思考：如果事務是自動提交的（SET AUTOCOMMIT = NO），且未手動開啟事務，執行如下兩條 SQL，插入的數據會是什麼樣子的？

INSERT INTO teacher (NAME, age) VALUE ('seven', 18) ;

INSERT INTO teacher (NAME, age) VALUE ('qingshan', 19) ;

因為事務是自動提交的，所以兩條插入語句會分別獲取事務ID，所以這裏插入的數據行的版本號是1和2。

刪除

上面圖中的執行步驟如下：

1. 手動開啟事務，從 InnoDB 引擎中獲取一個全局事務ID（22）
2. 然後執行一條刪除語句，InnoDB 會找到這條記錄，把它的刪除版本號設置為當前事務ID

修改

上面圖中的執行步驟如下：

1. 手動開啟事務，從 InnoDB 引擎中獲取一個全局事務ID（33）
2. 然後執行一條修改語句，InnoDB 會找到這條記錄，copy 一份原數據插入到表中，將新行數據的數據行的版本號的值設置為當前事務ID，將原行數據的刪除版本號的值設置為當前事務ID

查詢

上面圖中的執行步驟如下：

1. 手動開啟事務，從 InnoDB 引擎中獲取一個全局事務ID（44）
2. 根據數據查詢規則的描述

1. 查找數據行版本早於當前事務版本的數據行，發現表中三行數據都滿足條件
2. 查找刪除版本號要麼為 NULL，要麼大於當前事務版本號的記錄，發現只有最後一條數據滿足條件（1, seven, 19）

案例分析

數據準備：

CREATE TABLE `teacher` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) NOT NULL,
  `age` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4;

INSERT  INTO teacher(id,NAME,age) VALUES (1,'seven',18);
INSERT  INTO teacher(id,NAME,age) VALUES (2,'qingshan',20);

案例一

-- 事務A執行
BEGIN;                                     -- 1
SELECT * FROM teacher;                       -- 2
COMMIT;

--事務B執行
BEGIN;                                     -- 3
UPDATE teacher SET age =28 WHERE id=1;     -- 4
COMMIT;

案例一的執行步驟是：1,2,3,4,2，執行效果如下圖所示：

雖然在執行 3,4 步驟的時候更新 id=1 的數據，但是根據 MVCC 的查詢邏輯流程，再次執行2，獲取到的數據依然和第一次一樣。

案例二

-- 事務A執行
BEGIN;                                     -- 1
SELECT * FROM teacher;                       -- 2
COMMIT;

--事務B執行
BEGIN;                                     -- 3
UPDATE teacher SET age =28 WHERE id=1;     -- 4
COMMIT;

案例二的執行步驟是：3,4,1,2，執行效果如下圖所示：

根據 MVCC 的查詢邏輯流程，執行1,2，獲取到的數據是事務B未提交的數據，這個是有問題的。

分析了案例一和案例二，發現 MVCC 不能解決案例二的問題，InnoDB 會使用 Undo log 解決案例二的問題。

Undo Log

Undo Log 的定義

Undo：意為取消，以撤銷操作為目的，返回指定某個狀態的操作。

Undo Log：數據庫事務提交之前，會將事務修改數據的鏡像（即修改前的舊版本）存放到 undo 日誌里，當事務回滾時，或者數據庫奔潰時，可以利用 undo 日誌，即舊版本數據，撤銷未提交事務對數據庫產生的影響。。

• 對於 insert 操作，undo 日誌記錄新數據的 PK(ROW_ID)，回滾時直接刪除；
• 對於 delete/update 操作，undo 日誌記錄舊數據 row，回滾時直接恢復；
• 他們分別存放在不同的buffer里。

InnoDB 發現可以基於 Undo Log 來實現多版本併發控制。

分析下圖中 SQL 的執行過程。

• 事務A手動開啟事務，執行更新操作，首先會把更新命中的數據拷貝到 Undo Buffer 中
• 事務B手動開啟事務，執行查詢操作，會讀取 Undo Log 中數據返回，進行快照度

當前讀和快照讀

快照讀

SQL 讀取的數據是快照版本，也就是歷史版本，普通的 SELECT 就是快照讀。

InnoDB 快照讀，數據的讀取將由 cache（原本數據）+ Undo Log（事務修改過的數據）兩部分組成。

當前讀

SQL 讀取的數據是最新版本，通過鎖機制來保證讀取的數據無法通過其他事務進行修改。

UPDATE 、DELETE 、INSERT 、SELECT … LOCK IN SHARE MODE 、SELECT … FOR UPDATE 都是當前讀，這些操作在《MySQL InnoDB 鎖》這篇文章中有過演示，事務A執行這些 SQL，會阻塞事務B的 SQL 執行。

在 InnoDB 引擎裏面，快照讀通過 MVCC 解決幻讀的問題，當前讀通過 Next-Key Locks 解決幻讀的問題。

Redo Log

Redo Log 的定義

Redo：顧名思義就是重做。以恢復操作為目的，重現操作。

Redo Log：指事務中操作的任何數據，將最新的數據備份到一個地方（Redo Log）。

Redo Log 的持久化：不是隨着事務的提交才寫入的，而是在事務的執行過程中，便開始寫入 Redo Log 中，具體的落盤策略可以進行配置。

Redo Log 是為了實現事務的持久性而出現的產物。

Redo Log 實現事務持久性：防止在發生故障的時間點，尚有臟頁未寫入表的 IBD 文件中，在重啟 MySQL 服務的時候，根據 Redo Log 進行重做，從而達到事務的未入磁盤數據進行持久化這一特性。

根據下圖分析 Redo Log 的執行流程

InnoDB 不是每一次提交事務都把數據從緩存區持久化到硬盤的，因為每次提交事務都把數據持久化到硬盤，效率很低，每一次持久化都需要執行 IO 操作。

InnoDB 會把每次數據變化會先進入 Redo Buffer 中，事務提交了，會根據策略把新的數據寫入 Redo Log 中，InnoDB 就會認為這次事務提交成功了，數據並不一定馬上就進入表的 IBD 文件中。

疑問：持久化到 Redo Log 中和持久化到表的 IBD 文件一樣都是 IO 操作，為什麼要設計 Redo Log 呢？

其實是因為持久化到 Redo Log 中是順序 IO 的操作，而持久化到表的 IBD 文件中是一個隨機 IO 的操作，比如我們需要更新 id=1 和 id=8 的數據，如果是 Redo Log，就只需要把更新的數據順序存入 Redo Log 中；但如果是表的 IBD 文件，就需要先找到 id=1 和 id=8 的兩個不連續的磁盤文件地址，再做持久化操作，影響數據庫服務的併發性能。

Redo Log 的持久化配置

指定 Redo Log 記錄在 {datadir}/ib_logfile1 和 ib_logfile2 兩個文件中，可以通過 innodb_log_group_home_dir配置指定目錄存儲。

一旦事務成功提交且數據持久化到表的 IBD 文件中之後，此時 Redo Log 中的對應事務數據記錄就失去了意義，所 以 Redo Log 的寫入是日誌文件循環寫入的過程，也就是覆蓋寫的過程。

• 指定 Redo Log 日誌文件組中的數量 innodb_log_files_in_group 默認為2
• 指定 Redo Log 每一個日誌文件最大存儲量 innodb_log_file_size 默認48M
• 指定 Redo Log 在 cache/buffer 中的 buffer 池大小 innodb_log_buffer_size 默認16M

Redo Buffer 持久化到 Redo Log 的策略，通過設置 Innodb_flush_log_at_trx_commit 的值：

• 取值0：每秒提交 Redo buffer -> Redo Log OS cache -> flush cache to disk，可能丟失一秒內的事務數據。
• 取值1（默認值）：每次事務提交執行 Redo Buffer -> Redo Log OS cache -> flush cache to disk，最安全，性能最差的方式
• 取值2：每次事務提交執行 Redo Buffer -> Redo log OS cache 再每一秒執行 -> flush cache to disk 操作

一般建議選擇取值2，因為 MySQL 掛了最多損失一次事務提交的數據，整個服務期掛了才會損失一秒的事務提交數據。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

※大陸寄台灣空運注意事項

※大陸海運台灣交貨時間多久?

※避免吃悶虧無故遭抬價!台中搬家公司免費估價,有契約讓您安心有保障!

AQS是併發編程中非常重要的概念，它是juc包下的許多併發工具類，如CountdownLatch，CyclicBarrier，Semaphore 和鎖, 如ReentrantLock， ReaderWriterLock的實現基礎，提供了一個基於int狀態碼和隊列來實現的併發框架。本文將對AQS框架的幾個重要組成進行簡要介紹，讀完本文你將get到以下幾個點：

1. AQS進行併發控制的機制是什麼

2. AQS獨佔和共享模式是如何實現的

3. 同步隊列和條件等待隊列的區別，和數據出入隊原則

一，AQS基本概念

AQS（AbstractQueuedSynchronizer）是用來構建鎖或者其他同步組件的基礎框架，它使用了一個int成員變量來表示狀態，通過內置的FIFO（first in，first out）隊列來完成資源獲取線程的排隊工作。

隊列可分為兩種，一種是同步隊列，是程序執行入口出處的等待隊列；而另一種則是條件等待隊列，隊列中的元素是在程序執行時在某個條件上發生等待。

1.1 獨佔or共享模式

AQS支持兩種獲取同步狀態的模式既獨佔式和共享式。顧名思義，獨佔式模式同一時刻只允許一個線程獲取同步狀態，而共享模式則允許多個線程同時獲取。

1.2 同步隊列

當一個線程嘗試獲取同步狀態失敗時，同步器會將這個線程以及等待狀態等信息構造成一個節點加入到等待隊列中，同時會阻塞當前線程，當同步狀態釋放時，會把首節點中的線程喚醒，使其再次嘗試重複獲取同步隊列。

1.3 條件隊列

AQS內部類ConditionObject來實現的條件隊列，當一個線程獲取到同步狀態，但是卻通過Condition調用了await相關的方法時，會將該線程封裝成Node節點並加入到條件隊列中，它的結構和同步隊列相同。

二，獨佔or共享模式

AQS框架中，通過維護一個int類型的狀態，來進行併發控制，線程通常通過修改此狀態信息來表明當前線程持有此同步狀態。AQS則是通過保存修改狀態線程的引用來實現獨佔和共享模式的。

/**
 * 獲取同步狀態
 */
public final void acquire(int arg) {
    //嘗試獲取同步狀態， 如果嘗試獲取到同步狀態失敗，則加入到同步隊列中
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
/**
 * 嘗試獲取同步狀態【子類中實現】，因為aqs基於模板模式，僅提供基於狀態和同步隊列的實 
 * 現思路，具體的實現由子類決定
 */
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 如果當前狀態值為0，並且等待隊列中沒有元素，執行修改狀態值操作
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            // 修改狀態值成功，記錄當前持有同步狀態的線程信息
            setExclusiveOwnerThread(current);
            return true;
        }
        // 如果當前線程已經持有同步狀態，繼續修改同步狀態【重入鎖實現原理】
    } else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

/**
 * 根據傳入的模式以及當前線程信息創建一個隊列的節點並加入到同步隊列尾部
 */
private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    // Try the fast path of enq; backup to full enq on failure
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    enq(node);
    return node;
}
/**
 * 同步隊列中節點，嘗試獲取同步狀態
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        // 自旋(死循環)
        for (;;) {
            // 只有當前節點的前驅節點是頭節點時才會嘗試執行獲取同步狀態操作
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

獨佔式是如何控製得？

當修改狀態信息成功后，如果執行的是獨佔式操作，AQS的具體實現類中會保存當前線程的信息來聲明同步狀態已被當前線程佔用，此時其他線程再嘗試獲取同步狀態會返回false。

三，同步隊列

3.1 隊列中保存那些信息？

同步隊列節點中主要保存着線程的信息以及模式(共享or獨佔)。

3.2 何時執行入隊操作？

/**
 * 獲取同步狀態
 */
public final void acquire(int arg) {
    //嘗試獲取同步狀態， 如果嘗試獲取到同步狀態失敗，則加入到同步隊列中
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

復用上文中的代碼，不難看出再獲取同步狀態失敗后，會執行入隊操作。

3.3 何時執行出隊操作？

當線程獲取同步狀態失敗時，會被封裝成Node節點加入到等待隊列中，此時所有節點都回進入自旋過程，首先判斷自己prev是否時頭節點，如果是則嘗試獲取同步狀態。
被阻塞線程的喚醒主要以靠前驅節點的出隊或阻塞線程被中斷來實現。

/**
 * 同步隊列中節點，嘗試獲取同步狀態
 * 
 * 1. 當一個線程獲取到同步狀態時，會將當前線程構造程Node並設置為頭節點
 * 2. 並將原始的head節點設置為null，以便於垃圾回收
 */
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

四，條件等待隊列

條件變量（ConidtionObject）是AQS中的一個內部類，用來實現同步隊列機制。同步隊列復用了等待隊列中Node節點，所以同步隊列到等待隊列中不需要進行額外的轉換。

4.1 什麼時候執行入隊操作？

當線程獲取到同步狀態，但是在臨界區中調用了await()方法，此時該線程會被加入到對應的條件隊列匯總。
ps: 臨界區，加鎖和釋放鎖之間的代碼區域

/**
 * ConditionObject中的await方法，調用后使得當前執行線程加入條件等待隊列
 */
public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    Node node = addConditionWaiter();
    // -----省略代碼------
}
/**
 * 添加等待線程
 */
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // -----省略代碼------
    // 將當前線程構造程條件隊列節點，並加入到隊列中
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}

4.2 什麼時候執行出隊操作？

當對應的Conditioni調用signial/signalAll()方法時回選擇從條件隊列中出隊列，同步隊列是通過自旋的方式獲取同步狀態，而條件隊列中的節點則通過通知的方式出隊。條件隊列中的節點被喚醒後會加入到入口等待隊列中。

/**
 * 喚醒當前條件等到隊列中的所有等待線程
 */
public final void signalAll() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;
    if (first != null)
        doSignalAll(first);
}
/**
 * 遍歷隊列，將元素從條件隊列 加入到 同步隊列
 */
private void doSignalAll(Node first) {
    lastWaiter = firstWaiter = null;
    do {
        Node next = first.nextWaiter;
        first.nextWaiter = null;
        transferForSignal(first);
        first = next;
    } while (first != null);
}
final boolean transferForSignal(Node node) {
    // -----省略代碼------
    // 執行入隊操作，將node添加到同步隊列中
    Node p = enq(node);
    int ws = p.waitStatus;
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

五，總結

1. 使用Node實現的FIFO隊列，可以用於構建鎖或者其他同步裝置的基礎框架
2. 利用一個int類型的屬性表示狀態
3. 使用模板方法模式，子類可以通過繼承它來管理狀態實現各種併發工具
4. 可以同時實現獨佔和共享模式

本文對AQS的基本原理進行的簡要的描述，對於子類的公平性和非公平行實現，中斷，隊列中節點的等待狀態，cas等操作沒有進行探討，感興趣的小夥伴可以進行源碼閱讀或者查閱相關資料。

六，Q&A

Question1： 在java中通常使用synchronized來實現方法同步，AQS中通過CAS保證了修改同步狀態的一致性問題，那麼對比synchronized，cas有什麼優勢不同與優勢呢？你還知道其他無鎖併發的策略嗎？

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!!

※網頁設計一頭霧水??該從何著手呢? 找到專業技術的網頁設計公司，幫您輕鬆架站!

※想知道最厲害的台北網頁設計公司推薦、台中網頁設計公司推薦專業設計師”嚨底家”!!

※大陸寄台灣空運注意事項

※大陸海運台灣交貨時間多久?

※避免吃悶虧無故遭抬價!台中搬家公司免費估價,有契約讓您安心有保障!