併發控制是多個事務在併發執行時，資料庫保證事務一致性（Consistency）和隔離性（Isolation）的一種機制。主流商用關聯式資料庫使用的併發控制技術主要有三種：嚴格兩階段封鎖（S2PL）、多版本併發控制（MVCC）和樂觀併發控制（OCC）。
本文介紹了基於時間戳的併發控制，包括常規基於時間戳的併發控制、多版本基於時間戳鎖的併發控制、與時間戳相關的Google Percolator工程實踐和openGauss對PostgreSQL SI的最佳化改進等。

### 一、基於時間戳的併發控制
基於時間戳的併發控制，有常規的“單”版本併發控制，也有多版本基於時間戳併發控制。

#### 1、單版本基於時間戳的併發控制
  事務T在啟動時分配一個唯一的時間戳TS(T)，併發控制保證存在一個等價的序列排程，該排程中的事務是按事務的啟動時間先後順序，亦即事務按它們的啟動順序序列化而不是按提交的順序序列化。
為了實現這一點，基於時間戳順序併發控制使用以下資料結構儲存資料項x的以下資訊：
1.rt(x)：任何讀x的事務的最大時間戳
2.wt(x)：任何寫x的事務的最大時間戳
3.f(x)：標誌，用於表明最後寫x的事務是否已提交

使用上述資料結構進行讀寫併發控制的演算法如下：

**當事務T1請求讀x時**
1.第一種情況：TS(T1)wt(x)
讀事務的啟動時間大於最晚寫入時間，這時候又分為分兩種情況：
A.f(x)標記x已提交，則請求被批准，如TS(T1)>rt(x)，則更新rt(x)為TS(T1)
B.f(x)標記x未提交，則T1必須等待（否則會導致髒讀）

**當事務T1請求寫x時**
1.第一種情況：TS(T1) writes_;//資料快取Write
  int start_ts_;//事務開始時間

Transaction() : start_ts_(oracle.GetTimestamp()) {} //建構函式，初始化變數start_ts_
  
  /*
  輸入：Write結構體
  輸出：無
  實現：簡單的把Write物件（列值）push到Vector中
  */
  void Set(Write w) {//Set函式
    writes_.push_back(w); 
  }
  
  /*
  輸入：Row-行標識，Column-列標識
  輸出：value-列值，成功返回true，失敗（如沒有獲取值）返回false
  */
  bool Get(Row row, Column c, string* value) {
    while (true) {
    //Bigtable提供的行級事務
      bigtable::Txn T = bigtable::StartRowTransaction(row);
      // Check for locks that signal concurrent writes.
    // 檢查是否存在併發事務在寫資料
    // 注：SI的特點是寫不阻塞讀，讀不阻塞寫，但在這裡卻需要等待？
    //     原因是SI保證讀到的是事務開始(start_ts)之前已提交的資料，
    //     存在鎖意味著寫操作未完成且該操作的commit_ts可能在事務開始之前，
    //   但需要在寫入之後才能知道是否在start_ts之前，因此需要等待
      if (T.Read(row, c+"lock", [0, start_ts_])) { //判斷[0, start_ts_]內是否存在lock？
        // There is a pending lock; try to clean it and wait
    // 仍存在lock，等待
        BackoffAndMaybeCleanupLock(row, c);
        continue;
      }
      // Find the latest write below our start timestamp.
    //讀取最近已提交的資料版本
      latest write = T.Read(row, c+"write", [0, start_ts_]);
      if (!latest_write.found())
    //沒有資料，返回false
        return false; // no data
    //從Column+write中獲取start_ts
      int data_ts = latest_write.start_timestamp();
    //獲取真正的資料：Row+Column(column+"data")+start_ts
      *value = T.Read(row, c+"data", [data_ts, data_ts]);
      return true;
    }
  }
  
  // Prewrite tries to lock cell w, returning false in case of conflict.
  // 預寫入（理論基礎：透過意向表快取資料，執行延遲更新）
  /*  
  輸入：Write結構體，Write主節點
  輸出：成功返回true，失敗返回false
  */
  bool Prewrite(Write w, Write primary) {
  //獲取列
    Column c = w.col;
  //啟動Bigtable行事務
    bigtable::Txn T = bigtable::StartRowTransaction(w.row);
    // Abort on writes after our start timestamp ...
  // 存在比事務啟動時間start_ts更大的值,存在ww衝突,按照FUW原則,本事務回滾
    if (T.Read(w.row, c+"write", [start_ts_, ∞]))
      return false;
    // ... or locks at any timestamp.
  // 存在鎖,說明未完成的寫,即存在ww衝突,且其他事務比本事務更"早"獲得鎖,本事務回滾
    if (T.Read(w.row, c+"lock", [0, ∞]))
      return false;

//校驗完畢,可以寫資料
  //寫入資料:key=Row+Column(data)+start_ts,value=需寫入的值
    T.Write(w.row, c+"data", start_ts_, w.value);
  //上鎖,key=Row+Column(lock)+start_ts,value=主節點的行&列
    T.Write(w.row, c+"lock", start_ts_,
      {primary.row, primary.col}); // The primary’s location.
  //執行提交操作
    return T.Commit();
  }

//提交操作
  /*
  輸入：無
  輸出：成功返回true，失敗返回false
  */
  bool Commit() {
    // The primary’s location.
  // 陣列writes_的第一個元素為主節點
    Write primary = writes_[0];
  // 除第一個元素外，其他為從節點
    vector<write> secondaries(writes_.begin()+1, writes_.end());
  //主節點預寫入失敗
    if (!Prewrite(primary, primary))
      return false;
    //遍歷從節點，執行預寫入，一個節點不成功則全部失敗
    for (Write w : secondaries)
      if (!Prewrite(w, primary))
        return false;

//獲取事務提交時間戳
    int commit_ts = oracle_.GetTimestamp();
    // Commit primary first.
  // 主節點首先提交
    Write p = primary;
    //啟動Bigtable事務
  bigtable::Txn T = bigtable::StartRowTransaction(p.row);
  //謹慎起見，判斷是否存在鎖（本事務,start_ts唯一），避免重複寫入
    if (!T.Read(p.row, p.col+"lock", [start_ts_, start_ts_]))
      return false; // aborted while working
    //寫入：key=Row+Column(write)+commit_ts,value=start_ts,實際的值在key=Row+Column(data)+start_ts中
    T.Write(p.row, p.col+"write", commit_ts, start_ts_); // Pointer to data written at start_ts_.
  //刪除鎖
    T.Erase(p.row, p.col+"lock", commit_ts);
  //Bigtable事務提交
    if (!T.Commit())
      return false; // commit point
    // Second phase: write out write records for secondary cells.
  //遍歷從節點，寫key=Row+Column(write)+commit_ts,value=start_ts,同時刪除鎖
    for (Write w : secondaries) {
      bigtable::Write(w.row, w.col+"write", commit_ts, start_ts_);
      bigtable::Erase(w.row, w.col+"lock", commit_ts);
    }
    return true;
  }
} // class Transaction

```

### 三、openGauss對PostgreSQL SI的增強
在PostgreSQL中，可透過函式txid_current_snapshot()可獲取當前的快照資訊:
```
11:05:16 (xdb@[local]:5432)testdb=# select txid_current_snapshot();
 txid_current_snapshot 
-----------------------
 2404:2404:
(1 row)

11:24:11 (xdb@[local]:5432)testdb=# 
```
輸出格式為ST1 : ST2 : xip_list
其中:
ST1:最早仍活躍的事務ID,早於此XID的事務要麼被提交併可見，要麼回滾丟棄。
ST2:最後已完結事務(COMMITTED/ABORTED)的事務ID + 1。
xip_list:在"拍攝"快照時仍進行中的事務ID。該列表包含xmin和xmax之間的活動事務ID。
總結一下,簡單來說,對於給定的事務XID:
XID ∈ [1,ST1),過去的事務,對此快照均可見;
XID ∈ [ST1,ST2),不考慮子事務的情況,仍處於IN_PROGRESS狀態的,不可見;COMMITED狀態,可見;ABORTED狀態,不可見;
XID ∈ [ST2,∞),未來的事務,對此快照均不可見;

可以看到，對於XID ∈ [ST1,ST2)的事務ID，其判斷邏輯的複雜度與活躍事務數n成正比，演算法複雜度為O(n)。
但從快照隔離的機制以及基於時間戳的併發控制的理論可以看到，只要獲取讀時間（不同的隔離級別，讀時間不同）之前已提交事務的資料項版本即可，而這個演算法複雜度可以降低為O(1)。
openGauss引入了資料結構CSN(CommitSeqNo)，其最佳化原理如下圖所示：

![openGauss CSN](https://upload-images.jianshu.io/upload_images/8194836-dac5716fb0303aa3.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

已提交的XID對映為CSN（可以理解為邏輯意義上的時間戳），每次讀的時候，只需要把當前讀的邏輯時間戳與事務提交的邏輯時間戳進行簡單的對比即可得到可讀的元組版本。

下面是相關的程式碼片段：
```C++
typedef struct SnapshotData {
    SnapshotSatisfiesFunc satisfies; /* tuple test function */
    ...
    CommitSeqNo snapshotcsn;
    ...
}

//獲取快照
#ifndef ENABLE_MULTIPLE_NODES
Snapshot GetSnapshotData(Snapshot snapshot, bool force_local_snapshot, bool forHSFeedBack)
#else
Snapshot GetSnapshotData(Snapshot snapshot, bool force_local_snapshot)
#endif
{    
    ...
    //從執行緒變數中獲取CSN
    snapshot->snapshotcsn = t_thrd.xact_cxt.ShmemVariableCache->nextCommitSeqNo;
    ...
}

```

-- 獲取下一個XID和CSN
testdb=#  select gs_get_next_xid_csn();
 gs_get_next_xid_csn
---------------------
 (gaussdb,9540,1919)
(1 row)

-- 根據XID獲取相應的CSN
testdb=# select pgxc_get_csn('9537'::xid);
 pgxc_get_csn
--------------
         1918
(1 row)

```

### 四、參考資料
[1] Hector Garcia-Molina，Jeffrey D.Ullman，Jennifer Widom，《資料庫系統實現（第2版）》
[2] Daniel Peng，Frank Dabek，Large-scale Incremental Processing Using Distributed Transactions and Notifications
[3] 李國良，周敏奇，《openGauss資料庫核心技術》</write>

PostgreSQL 併發控制機制（3）：基於時間戳的併發控制

相關文章