迹忆客 专注技术分享

本篇文章介绍如何在 Go 语言中使用 rwmutex。

Go 语言 RWMutex

mutex 是 mutual exclusion 的缩写，用于随时跟踪哪个线程访问了某个变量。 互斥量是 GoLang 的 sync 包中提供的数据结构。

在使用 Go 代码执行并发时使用互斥锁。 下面是一个在 GoLang 中使用互斥量的简单示例。

package main

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

func EvenNumber(num int) bool {
    return num%2 == 0
}

func main() {
    num := 2
    var DemoMutex sync.Mutex

    go func() {
        DemoMutex.Lock()
        defer DemoMutex.Unlock()
        EvenNum := EvenNumber(num)
        time.Sleep(5 * time.Millisecond)
        if EvenNum {
            fmt.Println("The number", num, " is even")
            return
        }
        fmt.Println("The number", num, "is odd")
    }()

    go func() {
        DemoMutex.Lock()
        num++
        DemoMutex.Unlock()
    }()

    time.Sleep(time.Second)
}

上面的代码检查数字是偶数还是奇数。 这里并发的 goroutines 可能会破坏数据，所以我们使用互斥体来锁定和解锁数据以防止数据被破坏。

查看输出：

The number 2  is even

mutex和RWmutex的区别在于mutex是一个简单的mutex，而RWmutex是一个读写互斥锁。 使用 RWMutex，锁由任意数量的读取器或一个写入器持有。

当 RWMutex 的值为零时，它是一个未锁定的互斥体。 让我们用 RWMutex 互斥量尝试相同的例子。

package main

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

func EvenNumber(num int) bool {
    return num%2 == 0
}

func main() {
    num := 2
    var DemoRWM sync.RWMutex

    // both goroutines call DemoRWM.Lock() before accessing `num` and then call the DemoRWM.Unlock after they are done
    go func() {
        DemoRWM.RLock()
        defer DemoRWM.RUnlock()
        EvenNum := EvenNumber(num)
        time.Sleep(5 * time.Millisecond)
        if EvenNum {
            fmt.Println("The number", num, " is even")
            return
        }
        fmt.Println("The number", num, "is odd")
    }()

    go func() {
        DemoRWM.Lock()
        num++
        DemoRWM.Unlock()
    }()

    time.Sleep(time.Second)
}

正如我们在这里看到的，两个 goroutines 在访问 num 之前调用 DemoRWM.Lock() ，然后在完成后调用 DemoRWM.Unlock 。 该代码使用 RWMutex。

查看输出：

The number 2  is even

让我们尝试另一个 RWMutex 示例，其中 RWMutex 允许所有读取器同时访问数据，而写入器将锁定其他读取器。

看例子：

package main

import (
    "fmt"
    "sync"
)

func main() {
    DemoMap := map[int]int{}

    DemoRWM := &sync.RWMutex{}

    go LoopWrite(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)
    go LoopRead(DemoMap, DemoRWM)

    // stop the program from exiting must be killed
    StopBlock := make(chan struct{})
    <-StopBlock
}

func LoopRead(DemoMap map[int]int, DemoRWM *sync.RWMutex) {
    for {
        DemoRWM.RLock()
        for k, v := range DemoMap {
            fmt.Println(k, "-", v)
        }
        DemoRWM.RUnlock()
    }
}
func LoopWrite(DemoMap map[int]int, DemoRWM *sync.RWMutex) {
    for {
        for i := 0; i < 100; i++ {
            DemoRWM.Lock()
            DemoMap[i] = i
            DemoRWM.Unlock()
        }
    }
}

如我们所见，RWMutex 允许我们根据需要多次使用读取； 此代码的输出将如下所示：

timeout running program
0 - 0
0 - 0
0 - 0
0 - 0
0 - 0
0 - 0
0 - 0
0 - 0
1 - 1