1.行鎖數(shù)據(jù)結構
RocksDB鎖粒度最小是行，對于KV存儲而言，鎖對象就是key，每一個key對應一個LockInfo結構。所有key通過hash表管理，查找鎖時，直接通過hash表定位即可確定這個key是否已經(jīng)被上鎖。但如果全局只有一個hash表，會導致這個訪問這個hash表的沖突很多，影響并發(fā)性能。RocksDB首先按Columnfamily進行拆分，每個Columnfamily中的鎖通過一個LockMap管理，而每個LockMap再拆分成若干個分片，每個分片通過LockMapStripe管理，而hash表(std::unordered_map<std::string, LockInfo>)則存在于Stripe結構中，Stripe結構中還包含一個mutex和condition_variable，這個主要作用是，互斥訪問hash表，當出現(xiàn)鎖沖突時，將線程掛起，解鎖后，喚醒掛起的線程。這種設計很簡單但也帶來一個顯而易見的問題，就是多個不相關的鎖公用一個condition_variable，導致鎖釋放時，不必要的喚醒一批線程，而這些線程重試后，發(fā)現(xiàn)仍然需要等待，造成了無效的上下文切換。對比我們之前討論的InnoDB鎖機制，我們發(fā)現(xiàn)InnoDB是一個page里面的記錄復用一把鎖，而且復用是有條件的，同一個事務對一個page的若干條記錄加鎖才能復用；而且鎖等待隊列是精確等待，精確到記錄級別，不會導致的無效的喚醒。雖然RocksDB鎖設計比較粗糙，但也做了一定的優(yōu)化，比如在管理LockMaps時，通過在每個線程本地緩存一份拷貝lock_maps_cache_，通過全局鏈表將每個線程的cache鏈起來，當LockMaps變更時(刪除columnfamily)，則全局將每個線程的copy清空，由于columnfamily改動很少，所以大部分訪問LockMaps操作都是不需要加鎖的，提高了并發(fā)效率。
相關數(shù)據(jù)結構如下：

struct LockInfo {
bool exclusive; //排它鎖或是共享鎖
autovector<TransactionID> txn_ids; //事務列表，對于共享鎖而言，同一個key可以對應多個事務

// Transaction locks are not valid after this time in us
uint64_t expiration_time;
}

struct LockMapStripe { 
// Mutex must be held before modifying keys map
std::shared_ptr<TransactionDBMutex> stripe_mutex;

// Condition Variable per stripe for waiting on a lock
std::shared_ptr<TransactionDBCondVar> stripe_cv;

// Locked keys mapped to the info about the transactions that locked them.
std::unordered_map<std::string, LockInfo> keys;
}

struct LockMap {
const size_t num_stripes_; //分片個數(shù)
std::atomic<int64_t> lock_cnt{0}; //鎖數(shù)目
std::vector<LockMapStripe*> lock_map_stripes_; //鎖分片
}

class TransactionLockMgr {
using LockMaps = std::unordered_map<uint32_t, std::shared_ptr<LockMap>>;
LockMaps lock_maps_;

// Thread-local cache of entries in lock_maps_. This is an optimization
// to avoid acquiring a mutex in order to look up a LockMap
std::unique_ptr<ThreadLocalPtr> lock_maps_cache_;
}

2.行鎖空間代價
由于鎖信息是常駐內(nèi)存，我們簡單分析下RocksDB鎖占用的內(nèi)存。每個鎖實際上是unordered_map中的一個元素，則鎖占用的內(nèi)存為key_length+8+8+1，假設key為bigint，占8個字節(jié)，則100w行記錄，需要消耗大約22M內(nèi)存。但是由于內(nèi)存與key_length正相關，導致RocksDB的內(nèi)存消耗不可控。我們可以簡單算算RocksDB作為MySQL存儲引擎時，key_length的范圍。對于單列索引，最大值為2048個字節(jié)，具體可以參考max_supported_key_part_length實現(xiàn)；對于復合索引，索引最大長度為3072個字節(jié)，具體可以參考max_supported_key_length實現(xiàn)。假設最壞的情況，key_length=3072，則100w行記錄，需要消耗3G內(nèi)存，如果是鎖1億行記錄，則需要消耗300G內(nèi)存，這種情況下內(nèi)存會有撐爆的風險。因此RocksDB提供參數(shù)配置max_row_locks，確保內(nèi)存可控，默認RDB_MAX_ROW_LOCKS設置為1G，對于大部分key為bigint場景，極端情況下，也需要消耗22G內(nèi)存。而在這方面，InnoDB則比較友好，hash表的key是(space_id, page_no)，所以無論key有多大，key部分的內(nèi)存消耗都是恒定的。前面我也提到了InnoDB在一個事務需要鎖大量記錄場景下是有優(yōu)化的，多個記錄可以公用一把鎖，這樣也間接可以減少內(nèi)存。

3.上鎖流程分析
前面簡單了解了RocksDB鎖數(shù)據(jù)結構的設計以及鎖對內(nèi)存資源的消耗。這節(jié)主要介紹幾種典型場景下，RocksDB是如何加鎖的。與InnoDB一樣，RocksDB也支持MVCC，讀不上鎖，為了方便，下面的討論基于RocksDB作為MySQL的一個引擎來展開，主要包括三類，基于主鍵的更新，基于二級索引的更新，基于主鍵的范圍更新等。在展開討論之前，有一點需要說明的是，RocksDB與InnoDB不同，RocksDB的更新也是基于快照的，而InnoDB的更新基于當前讀，這種差異也使得在實際應用中，相同隔離級別下，表現(xiàn)有所不一樣。對于RocksDB而言，在RC隔離級別下，每個語句開始都會重新獲取一次快照；在RR隔離級別下，整個事務中只在第一個語句開始時獲取一次快照，所有語句共用這個快照，直到事務結束。

3.1.基于主鍵的更新
這里主要接口是TransactionBaseImpl::GetForUpdate
1).嘗試對key加鎖，如果鎖被其它事務持有，則需要等待
2).創(chuàng)建snapshot
3).調(diào)用ValidateSnapshot，Get key,通過比較Sequence判斷key是否被更新過
4).由于是加鎖后，再獲取snapshot，所以檢查一定成功。
5).執(zhí)行更新操作
這里有一個延遲獲取快照的機制，實際上在語句開始時，需要調(diào)用acquire_snapshot獲取快照，但為了避免沖突導致的重試，在對key加鎖后，再獲取snapshot，這就保證了在基于主鍵更新的場景下，不會存在ValidateSnapshot失敗的場景。

堆棧如下：

1-myrocks::ha_rocksdb::get_row_by_rowid
2-myrocks::ha_rocksdb::get_for_update
3-myrocks::Rdb_transaction_impl::get_for_update
4-rocksdb::TransactionBaseImpl::GetForUpdate
{
//加鎖
5-rocksdb::TransactionImpl::TryLock
  6-rocksdb::TransactionDBImpl::TryLock
    7-rocksdb::TransactionLockMgr::TryLock 

 //延遲獲取快照，與acquire_snapshot配合使用
 6-SetSnapshotIfNeeded()

 //檢查key對應快照是否過期
 6-ValidateSnapshot
  7-rocksdb::TransactionUtil::CheckKeyForConflict
    8-rocksdb::TransactionUtil::CheckKey
      9-rocksdb::DBImpl::GetLatestSequenceForKey //第一次讀取

//讀取key
5-rocksdb::TransactionBaseImpl::Get
  6-rocksdb::WriteBatchWithIndex::GetFromBatchAndDB
    7-rocksdb::DB::Get
      8-rocksdb::DBImpl::Get
        9-rocksdb::DBImpl::GetImpl //第二次讀取
}

3.2.基于主鍵的范圍更新
1).創(chuàng)建Snapshot，基于迭代器掃描主鍵
2).通過get_row_by_rowid，嘗試對key加鎖
3).調(diào)用ValidateSnapshot，Get key,通過比較Sequence判斷key是否被更新過
4).如果key被其它事務更新過(key對應的SequenceNumber比Snapshot要新)，觸發(fā)重試
5).重試情況下，會釋放老的快照并釋放鎖，通過tx->acquire_snapshot(false)，延遲獲取快照(加鎖后，再拿snapshot)
5).再次調(diào)用get_for_update，由于此時key已經(jīng)被加鎖，重試一定可以成功。
6).執(zhí)行更新操作
7).跳轉(zhuǎn)到1，繼續(xù)執(zhí)行，直到主鍵不符合條件時，則結束。

3.3.基于二級索引的更新
這種場景與3.2類似，只不過多一步從二級索引定位主鍵過程。
1).創(chuàng)建Snapshot，基于迭代器掃描二級索引
2).根據(jù)二級索引反向找到主鍵，實際上也是調(diào)用get_row_by_rowid，這個過程就會嘗試對key加鎖
3).繼續(xù)根據(jù)二級索引遍歷下一個主鍵，嘗試加鎖
4).當返回的二級索引不符合條件時，則結束

3.4 與InnoDB加鎖的區(qū)別
前面我們說到了RocksDB與InnoDB的一點區(qū)別是，對于更新場景，RocksDB仍然是快照讀，而InnoDB是當前讀，導致行為上的差異。比如在RC隔離級別下的范圍更新場景，比如一個事務要更新1000條記錄，由于是邊掃描邊加鎖，可能在掃描到第999條記錄時，發(fā)現(xiàn)這個key的Sequence大于掃描的快照(這個key被其它事務更新了)，這個時候會觸發(fā)重新獲取快照，然后基于這個快照拿到最新的key值。InnoDB則沒有這個問題，通過當前讀，掃描過程中，如果第999條記錄被更新了，InnoDB可以直接看到最新的記錄。這種情況下，RocksDB和InnoDB看到的結果是一樣的。在另外一種情況下，假設也是掃描的范圍中，新插入了key，這key的Sequence毫無疑問會比掃描的Snapshot要大，因此在Scan過程中這個key會被過濾掉，也就不存在所謂的沖突檢測了，這個key不會被找到。更新過程中，插入了id為1和900的兩條記錄，最后第900條記錄由于不可見，所以更新不到。而對于InnoDB而言，由于是當前讀，新插入的id為900的記錄可以被看到并更新，所以這里是與InnoDB有區(qū)別的地方。
除了更新基于快照這個區(qū)別以外，RocksDB在加鎖上也更簡潔，所有加鎖只涉及唯一索引，具體而言，在更新過程中，只對主鍵加鎖；更新列涉及唯一約束時，需要加鎖；而普通二級索引，則不用加鎖，這個目的是為了避免唯一約束沖突。這里面，如果更新了唯一約束(主鍵，或者唯一索引)，都需要加鎖。而InnoDB則是需要對每個索引加鎖，比如基于二級索引定位更新，則二級索引也需要加鎖。之所以有這個區(qū)別是，是因為InnoDB為了實現(xiàn)RR隔離級別。這里稍微講下隔離級別，實際上MySQL中定義的RR隔離級別與SQL標準定義的隔離級別有點不一樣。SQL標準定義RR隔離級別解決不可重復讀的問題，Serializable隔離級別解決幻讀問題。不可重復讀側重講同一條記錄值不會修改；而幻讀則側重講兩次讀返回的記錄條數(shù)是固定的，不會增加或減少記錄數(shù)目。MySQL定義RR隔離級別同時解決了不可重復讀和幻讀問題，而InnoDB中RR隔離級別的實現(xiàn)就是依賴于GAP鎖。而RocksDB不支持GAP鎖(僅僅支持唯一約束檢查，對不存在的key加鎖)，因為基于快照的機制可以有效過濾掉新插入的記錄，而InnoDB由于當前讀，導致需要通過間隙鎖禁止其它插入，所以二級索引也需要加鎖，主要是為了鎖間隙，否則兩次當前讀的結果可能不一樣。當然，對RC割裂級別，InnoDB普通二級索引也是沒有必要加鎖的。

4.死鎖檢測算法
死鎖檢測采用DFS((Depth First Search,深度優(yōu)先算法)，基本思路根據(jù)加入等待關系，繼續(xù)查找被等待者的等待關系，如果發(fā)現(xiàn)成環(huán)，則認為發(fā)生了死鎖，當然在大并發(fā)系統(tǒng)下，鎖等待關系非常復雜，為了將死鎖檢測帶來的資源消耗控制在一定范圍，可以通過設置deadlock_detect_depth來控制死鎖檢測搜索的深度，或者在特定業(yè)務場景下，認為一定不會發(fā)生死鎖，則關閉死鎖檢測，這樣在一定程度上有利于系統(tǒng)并發(fā)的提升。需要說明的是，如果關閉死鎖，最好配套將鎖等待超時時間設置較小，避免系統(tǒng)真發(fā)生死鎖時，事務長時間hang住。死鎖檢測基本流程如下：
1.定位到具體某個分片，獲取mutex
2.調(diào)用AcquireLocked嘗試加鎖
3.若上鎖失敗，則觸發(fā)進行死鎖檢測
4.調(diào)用IncrementWaiters增加一個等待者
5.如果等待者不在被等待者map里面，則肯定不會存在死鎖，返回
6.對于被等待者，沿著wait_txn_map_向下檢查等待關系，看看是否成環(huán)
7.若發(fā)現(xiàn)成環(huán)，則將調(diào)用DecrementWaitersImpl將新加入的等待關系解除，并報死鎖錯誤。

相關的數(shù)據(jù)結構：

class TransactionLockMgr {
// Must be held when modifying wait_txn_map_ and rev_wait_txn_map_.
std::mutex wait_txn_map_mutex_;

// Maps from waitee -> number of waiters.
HashMap<TransactionID, int> rev_wait_txn_map_;

// Maps from waiter -> waitee.
HashMap<TransactionID, autovector<TransactionID>> wait_txn_map_;

DecrementWaiters //

IncrementWaiters //
}

struct TransactionOptions {
bool deadlock_detect = false; //是否檢測死鎖
int64_t deadlock_detect_depth = 50; //死鎖檢測的深度
int64_t lock_timeout = -1; //等待鎖時間，線上一般設置為5s
int64_t expiration = -1; //持有鎖時間，
}

以上就是RocksDB上鎖機制的實例詳解的詳細內(nèi)容，更多請關注php中文網(wǎng)其它相關文章！