Go讀寫鎖操作方法示例詳解

Posted on by

引言

前面講到，在資源競爭的時候可以使用互斥鎖，保證瞭資源訪問的唯一性，但也降低瞭性能，仔細分析一下場景，如果隻是讀取數據，無論多少個goroutine都是不會存在邏輯上的互斥操作的。

這裡讀寫鎖🔐 RWMutex就應運而生瞭，RWMutex可以分別針對讀操作和寫操作進行上鎖和解鎖。

RWMutex同一時刻允許多個讀操作進行，但隻允許一個寫操作進行，同時，在某一個寫操作進行的時候，讀操作不可進行。

讀寫鎖有很多方法

  • 方法一： RLock 這個方法是讀鎖，當寫鎖存在的時候，無法加載讀鎖，隻有當不存在鎖，或者隻有讀鎖的時候才能使用。讀鎖可以同時加載多個，適用於多度寫少的場景。
  • 方法二： RUnlock 這個方法是讀解鎖，用來撤銷單次的讀鎖操作。
  • 方法三： Lock 這個方法是寫上鎖，如果在添加寫上鎖之前已經有其他的讀鎖和寫鎖瞭，此時，這個Lock會被阻塞，直到可以使用。
  • 方法四： Unlock 這個方法是寫解鎖，如果沒有綁定寫鎖就直接寫解鎖，會引發運行時錯誤。

讀操作

下面用實際的代碼做例子,看一下讀操作：

package main
import (
    "fmt"
    "sync"
    "time"
)
//新建一個鎖對象的指針，然後待會兒再指針中創建這個鎖的對象
var rwMutex *sync.RWMutex
//為瞭保證 子的goroutine先執行，可以使用同步等待組wg,這裡創建wg的指針類型
var wg *sync.WaitGroup
func main() {
    rwMutex = new(sync.RWMutex)
    wg = new(sync.WaitGroup)
    wg.Add(2)//這裡記得+add
    //    在主函數中 啟動2條goroutine
    go readData(1)
    go readData(2)
    wg.Wait()
    fmt.Println("main func end")
}
func readData(i int) {
    defer wg.Done()
    fmt.Println(i, "start locking!")
    //    給讀操作 上鎖
    rwMutex.RLock()
    //    讀數據
    fmt.Println(i, "Reading data")
    //  睡一下
    time.Sleep(1 * time.Second)
    //    讀解鎖
    rwMutex.RUnlock()
    //打印提示信息
    fmt.Println(i, "Read over")
}

代碼運行結果如下：

2 start locking!
2 Reading data
1 start locking!
1 Reading data
2 Read over
1 Read over
main func end

從打印結果可知，第二條goroutine先上讀鎖，然後第二條開始讀取，然後第一條上讀鎖【從這裡就可以看出，因為第二條的讀鎖還沒讀解鎖，第一條的讀鎖就上瞭，所以這裡的讀鎖並不互斥】，之後第一條開始讀取，第二條讀解鎖，第一條讀解鎖。主goroutine結束。

寫操作

package main
import (
    "fmt"
    "sync"
    "time"
)
//新建一個鎖對象的指針，然後待會兒再指針中創建這個鎖的對象
var rwMutex *sync.RWMutex
//為瞭保證 子的goroutine先執行，可以使用同步等待組wg,這裡創建wg的指針類型
var wg *sync.WaitGroup
func main() {
    rwMutex = new(sync.RWMutex)
    wg = new(sync.WaitGroup)
    wg.Add(4)
    //    在主函數中 啟動2條goroutine
    go readData(1)
    go readData(2)
    go writeData(3)
    go writeData(4)
    wg.Wait()
    fmt.Println("main func end")
}
func readData(i int) {
    defer wg.Done()
    fmt.Println(i, "start locking!")
    //    給讀操作 上鎖
    rwMutex.RLock()
    //    讀數據
    fmt.Println(i, "Reading data")
    //  睡一下
    time.Sleep(1 * time.Second)
    //    讀解鎖
    rwMutex.RUnlock()
    //打印提示信息
    fmt.Println(i, "Read over")
}
func writeData(i int) {
    defer wg.Done()
    fmt.Println(i, " Writing Start")
    //寫上鎖
    rwMutex.Lock()
    fmt.Println(i, "~~~ writing right now~~~")
    time.Sleep(1 * time.Second)
    rwMutex.Unlock()
    fmt.Println(i, "writing completed")
}

代碼運行結果如下：

2 start locking!
2 Reading data
4  Writing Start
1 start locking!
3  Writing Start
2 Read over
4 ~~~ writing right now~~~
4 writing completed
1 Reading data
1 Read over
3 ~~~ writing right now~~~
3 writing completed
main func end

分析可知，隻有在goroutine4結束寫之後goroutine3才拿到權限開始寫。

不過講真，到處都是lock 和 unlock，臨界區什麼的，真的是臃腫又容易出問題。
go語言中多個協程想共享數據的時候，將會有更加優雅的處理方式。

以上就是Go讀寫鎖方法示例詳解的詳細內容，更多關於Go讀寫鎖方法的資料請關註WalkonNet其它相關文章！

推薦閱讀：