Golang互斥锁——读写锁

Golang互斥锁——读写锁

Golang原生支持并发应用，几乎没有其他语言默认支持如此多的并发实现工具。本文在上文的基础上讲解读写锁。

1. 互斥锁解决什么问题

我们并不希望多个线程或协程同时访问相同内存。在并发应用中，很多不同的线程或协程很有可能同时访问相同内存变量。
互斥锁可以实现避免同时读写问题。当一个线程写内存变量，同时另一个线程并发读相同的内存变量。程序将会报错，因为读取线程可能正在读错误数据，这些数据正在发生变化。互斥锁跟踪在任何给定时间哪个线程可以访问一个变量。

2. 互斥锁示例

请看下面程序：

package main

import (
    "fmt"
)

func main() {
    m := map[int]int{}
    go writeLoop(m)
    go readLoop(m)

    // 阻塞程序，手动结束
    block := make(chan struct{})
    <-block
}

func writeLoop(m map[int]int) {
    for {
        for i := 0; i < 100; i++ {
            m[i] = i
        }
    }
}

func readLoop(m map[int]int) {
    for {
        for k, v := range m {
            fmt.Println(k, "-", v)
        }
    }
}

map

fatal error: concurrent map iteration and map write

Go认为同时读写map不安全，程序异常结束。

2.1 互斥锁实现

package main

import (
    "fmt"
    "sync"
)

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

    mux := &sync.Mutex{}

    go writeLoop(m, mux)
    go readLoop(m, mux)

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

func writeLoop(m map[int]int, mux *sync.Mutex) {
    for {
        for i := 0; i < 100; i++ {
            mux.Lock()
            m[i] = i
            mux.Unlock()
        }
    }
}

func readLoop(m map[int]int, mux *sync.Mutex) {
    for {
        mux.Lock()
        for k, v := range m {
            fmt.Println(k, "-", v)
        }
        mux.Unlock()
    }
}

Lock()Unlock()

2.2 RWMutex ———— 安全实现并发读

Map可以安全地并发访问，但不能并发读/写或写/写。读写锁支持多个读协程同时访问map，但写锁排斥其他协程。

package main

import (
    "fmt"
    "sync"
)

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

    mux := &sync.RWMutex{}

    go writeLoop(m, mux)
    go readLoop(m, mux)
    go readLoop(m, mux)
    go readLoop(m, mux)
    go readLoop(m, mux)

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

func writeLoop(m map[int]int, mux *sync.RWMutex) {
    for {
        for i := 0; i < 100; i++ {
            mux.Lock()
            m[i] = i
            mux.Unlock()
        }
    }
}

func readLoop(m map[int]int, mux *sync.RWMutex) {
    for {
        mux.RLock()
        for k, v := range m {
            fmt.Println(k, "-", v)
        }
        mux.RUnlock()
    }
}

sync.RWMutex

3. 总结

本文通过示例介绍互斥锁，读写互斥锁可以更高效并发读。