快捷導(dǎo)航

Golang并發(fā)之RWMutex的用法詳解

更新時(shí)間：2023年04月06日 09:27:56 作者：陳明勇

在?Go?語(yǔ)言中，RWMutex?是一種讀寫互斥鎖的實(shí)現(xiàn)，它提供了一種簡(jiǎn)單有效的方式來(lái)管理對(duì)共享資源的并發(fā)訪問。本文就來(lái)和大家詳細(xì)聊聊RWMutex的用法吧

前言

在這篇文章 Go Mutex：保護(hù)并發(fā)訪問共享資源的利器中，主要介紹了 Go 語(yǔ)言中互斥鎖 Mutex 的概念、對(duì)應(yīng)的字段與方法、基本使用和易錯(cuò)場(chǎng)景，最后基于 Mutex 實(shí)現(xiàn)一個(gè)簡(jiǎn)單的協(xié)程安全的緩存。而本文，我們來(lái)看看另一個(gè)更高效的 Go 并發(fā)原語(yǔ)，RWMutex。

準(zhǔn)備好了嗎？喝一杯你最喜歡的飲料，隨著文章一起進(jìn)入 RWMutex 令人興奮的世界！

說(shuō)明：本文使用的代碼基于的 Go 版本：1.20.1

RWMutex

讀寫互斥鎖是一種同步原語(yǔ)，它允許多個(gè)協(xié)程同時(shí)訪問共享資源，同時(shí)確保一次只有一個(gè)協(xié)程可以修改資源。相較于互斥鎖，讀寫互斥鎖在讀操作比寫操作更頻繁的情況下，可以帶來(lái)更好的性能表現(xiàn)。

在 Go 語(yǔ)言中，RWMutex 是一種讀寫互斥鎖的實(shí)現(xiàn)，它提供了一種簡(jiǎn)單有效的方式來(lái)管理對(duì)共享資源的并發(fā)訪問。它提供了兩種類型的鎖：讀鎖和寫鎖。

1、讀鎖（RLock() 、TryRLock() 和 RUnlock() 方法）

RWMutex 的讀鎖是一種共享鎖，當(dāng)一個(gè)協(xié)程獲取了讀鎖后，其他協(xié)程也可以同時(shí)獲取讀鎖，從而允許并發(fā)的讀操作。

2、寫鎖（Lock()、TryLock() 和 Unlock() 方法）

RWMutex 的寫鎖是一種獨(dú)占鎖，當(dāng)一個(gè)協(xié)程獲取了寫鎖后，其他協(xié)程無(wú)法獲取讀鎖或?qū)戞i，直到該協(xié)程釋放寫鎖。在寫鎖未被釋放之前，任何想要獲取讀鎖或?qū)戞i的 goroutine 都會(huì)被阻塞。

RWMutex 結(jié)構(gòu)體介紹

type RWMutex struct {
   w           Mutex        
   writerSem   uint32       // 寫操作等待者
   readerSem   uint32       // 讀操作等待者 
   readerCount atomic.Int32 // 持有讀鎖的 goroutine 數(shù)量
   readerWait  atomic.Int32 // 請(qǐng)求寫鎖時(shí)，需要等待完成的讀鎖數(shù)量
}

RWMutex 由以下字段組成：

w: 為互斥鎖，用于實(shí)現(xiàn)寫操作之間的互斥。
writerSem：寫操作的信號(hào)量。當(dāng)有 goroutine 請(qǐng)求寫操作時(shí)，如果有其他的 goroutine 正在執(zhí)行讀操作，則請(qǐng)求寫操作的 goroutine 將會(huì)被阻塞，直到所有的讀操作完成后，通過 writerSem 信號(hào)量解除阻塞。
readerSem：讀操作的信號(hào)量。當(dāng)有 goroutine 請(qǐng)求讀操作時(shí)，如果此時(shí)存在寫操作，則請(qǐng)求讀操作的 goroutine 將會(huì)被阻塞，直到寫操作執(zhí)行完成后，通過 readerSem 信號(hào)量解除阻塞并繼續(xù)執(zhí)行。
readerCount：讀操作的goroutine數(shù)量，當(dāng)readerCount為正數(shù)時(shí)，表示有一個(gè)或多個(gè)讀操作正在執(zhí)行，如果 readerCount 的值為負(fù)數(shù)，說(shuō)明有寫操作正在等待。
readerWait：寫操作的 goroutine 等待讀操作完成的數(shù)量。當(dāng)一個(gè)寫操作請(qǐng)求執(zhí)行時(shí)，如果此時(shí)有一個(gè)或多個(gè)讀操作正在執(zhí)行，則會(huì)將讀操作的數(shù)量記錄到readerWait中，并阻塞寫操作所在的goroutine。寫操作所在的goroutine會(huì)一直阻塞，直到正在執(zhí)行的所有讀操作完成，此時(shí)readerWait的值將被更新為 0，并且寫操作所在的goroutine將被喚醒。

RWMutex 常用方法：

Lock()：獲取寫鎖，擁有寫操作的權(quán)限；如果讀操作正在執(zhí)行，此方法將會(huì)阻塞，直到所有的讀操作執(zhí)行結(jié)束。
Unlock()：釋放寫鎖,并喚醒其他請(qǐng)求讀鎖的 goroutine。
TryLock()：嘗試獲取寫鎖，如果獲取成功，返回 true，否則返回 false，不存在阻塞的情況。
RLock()：獲取讀鎖，讀鎖是共享鎖，可以被多個(gè) goroutine 獲取，但是如果有寫操作正在執(zhí)行或等待執(zhí)行時(shí)，此方法將會(huì)阻塞，直到寫操作執(zhí)行結(jié)束。
RUnlock()：釋放讀鎖，如果所有讀操作都結(jié)束并且有等待執(zhí)行的寫操作，則會(huì)喚醒對(duì)應(yīng)的 goroutine。
TryRlock()：嘗試獲取讀鎖，如果獲取成功，返回 true，否則返回 false，不存在阻塞的情況。

簡(jiǎn)單讀寫場(chǎng)景示例

package main

import (
   "fmt"
   "sync"
   "time"
)

type Counter struct {
   value   int
   rwMutex sync.RWMutex
}

func (c *Counter) GetValue() int {
   c.rwMutex.RLock()
   defer c.rwMutex.RUnlock()
   return c.value
}

func (c *Counter) Increment() {
   c.rwMutex.Lock()
   defer c.rwMutex.Unlock()
   c.value++
}
func main() {
   counter := Counter{value: 0}

   // 讀操作
   for i := 0; i < 10; i++ {
      go func() {
         for {
            fmt.Println("Value: ", counter.GetValue())
            time.Sleep(time.Millisecond)
         }
      }()
   }

   // 寫操作
   for {
      counter.Increment()
      time.Sleep(time.Second)
   }
}

上述代碼示例中定義了一個(gè) Counter 結(jié)構(gòu)體，包含一個(gè) value 字段和一個(gè) sync.RWMutex 實(shí)例 rwMutex。該結(jié)構(gòu)體還實(shí)現(xiàn)了兩個(gè)方法：GetValue() 和 Increment()，分別用于讀取 value 字段的值和對(duì) value 字段的值加一。這兩個(gè)方法在訪問 value 字段時(shí)，使用了讀寫鎖來(lái)保證并發(fā)安全。

在 main() 函數(shù)中，首先創(chuàng)建了一個(gè) Counter 實(shí)例 counter，然后啟動(dòng)了 10 個(gè)協(xié)程，每個(gè)協(xié)程會(huì)不斷讀取 counter 并打印到控制臺(tái)上。同時(shí)，main() 函數(shù)也會(huì)不斷對(duì) counter 的 value 值加 1，每次加 1 的操作都會(huì)休眠 1 秒鐘。由于使用了讀寫鎖，多個(gè)讀操作可以同時(shí)進(jìn)行，而寫操作則會(huì)互斥進(jìn)行，保證了并發(fā)安全。

基于 RWMutex 實(shí)現(xiàn)一個(gè)簡(jiǎn)單的協(xié)程安全的緩存

在 Go Mutex：保護(hù)并發(fā)訪問共享資源的利器文章中，使用了 Mutex 實(shí)現(xiàn)了一個(gè)簡(jiǎn)單的線程安全的緩存，但并不是最優(yōu)的設(shè)計(jì)，對(duì)于緩存場(chǎng)景，讀操作比寫操作更頻繁，因此使用 RWMutex 代替 Mutex 會(huì)更好。

import "sync"

type Cache struct {
   data    map[string]any
   rwMutex sync.RWMutex
}

func NewCache() *Cache {
   return &Cache{
      data: make(map[string]any),
   }
}

func (c *Cache) Get(key string) (any, bool) {
   c.rwMutex.RLock()
   defer c.rwMutex.RUnlock()
   value, ok := c.data[key]
   return value, ok
}

func (c *Cache) Set(key string, value any) {
   c.rwMutex.Lock()
   defer c.rwMutex.Unlock()
   c.data[key] = value
}

上述代碼實(shí)現(xiàn)了一個(gè)協(xié)程安全的緩存，通過使用 RWMutex 的讀寫鎖，保證了 Get() 方法可以被多個(gè) goroutine 并發(fā)地執(zhí)行，而且只有在讀操作和寫操作同時(shí)存在時(shí)才會(huì)進(jìn)行互斥鎖定，有效地提高了并發(fā)性能。

RWMutex 易錯(cuò)場(chǎng)景

沒有正確的加鎖和解鎖

為了正確使用讀寫鎖，必須正確使用鎖的方法。對(duì)于讀操作，必須成對(duì)使用 RLock() 和 RUnlock() 方法，否則可能會(huì)導(dǎo)致程序 panic 或阻塞。

例如：如果缺少 RLock()，直接使用 RUnlock()方法，程序?qū)?huì) panic，如果缺少 RUnlock() 方法，將會(huì)發(fā)生阻塞的形象。

同樣，對(duì)于寫操作，必須成對(duì)使用 Lock() 和 Unlock() 方法。

最佳實(shí)踐是使用 defer 來(lái)釋放鎖：為了保證鎖總是被釋放，即使在運(yùn)行時(shí)錯(cuò)誤或提前返回的情況下，也可以在獲得鎖后立即使用 defer 關(guān)鍵字來(lái)調(diào)度相應(yīng)的解鎖方法。

rwMutex.RLock()
defer rwMutex.RUnlock()
// 讀操作

rwMutex.Lock()
defer rwMutex.Unlock()
// 寫操作

重復(fù)加鎖

重復(fù)加鎖操作被稱為可重入操作。不同于其他一些編程語(yǔ)言的鎖實(shí)現(xiàn)（例如 Java 的 ReentrantLock），Go 的 mutex 并不支持可重入操作。

由于 RWMutex 內(nèi)部是基于 Mutex 實(shí)現(xiàn)的寫操作互斥，如果發(fā)生了重復(fù)加鎖操作，就會(huì)導(dǎo)致死鎖。這個(gè)易錯(cuò)場(chǎng)景在上篇文章中也提到了，還給出了代碼示例，感興趣的小伙伴可以去看看。

讀操作內(nèi)嵌寫操作

當(dāng)有協(xié)程執(zhí)行讀操作時(shí)，請(qǐng)求執(zhí)行寫操作的協(xié)程會(huì)被阻塞。如果在讀操作中嵌入寫操作的代碼，寫操作將調(diào)用 Lock() 方法，從而導(dǎo)致讀操作和寫操作之間形成相互依賴關(guān)系。在這種情況下，讀操作會(huì)等待寫操作完成后才能執(zhí)行 RUnlock()，而寫操作則會(huì)等待讀操作完成后才能被喚醒繼續(xù)執(zhí)行，從而導(dǎo)致死鎖的狀態(tài)。