GO语言：sync包——读写锁

缺乏、安全感 2023-10-06 15:23 55阅读 0赞

官网文档对sync包的介绍：

Package sync provides basic synchronization primitives such as mutual exclusion locks. Other than the Once and WaitGroup types, most are intended for use by low-level library routines. Higher-level synchronization is better done via channels and communication.

![1ab708f8ccf14be69b873424f197f91b.png][]

sync是synchronization同步这个词的缩写，所以也会叫做同步包。这里提供了基本同步的操作，比如互斥锁等等。这里除了Once和WaitGroup类型之外，大多数类型都是供低级库例程使用的。更高级别的同步最好通过channel通道和communication通信来完成

### **一、RWMutex(读写锁)** ###

通过对互斥锁的学习，我们已经知道了锁的概念以及用途。主要是用于处理并发中的临界资源问题。

Go语言包中的 sync 包提供了两种锁类型：sync.Mutex 和 sync.RWMutex。其中RWMutex是基于Mutex实现的，只读锁的实现使用类似引用计数器的功能。

RWMutex是读/写互斥锁。锁可以由任意数量的读取器或单个编写器持有。RWMutex的零值是未锁定的mutex。

如果一个goroutine持有一个rRWMutex进行读取，而另一个goroutine可能调用lock，那么在释放初始读取锁之前，任何goroutine都不应该期望能够获取读取锁。特别是，这禁止递归读取锁定。这是为了确保锁最终可用；被阻止的锁调用会将新的读卡器排除在获取锁之外。

![0fdf6a3411814344b324725f3eb79cfc.png][]

我们怎么理解读写锁呢？当有一个 goroutine 获得写锁定，其它无论是读锁定还是写锁定都将阻塞直到写解锁；当有一个 goroutine 获得读锁定，其它读锁定仍然可以继续；当有一个或任意多个读锁定，写锁定将等待所有读锁定解锁之后才能够进行写锁定。所以说这里的读锁定（RLock）目的其实是告诉写锁定：有很多人正在读取数据，你给我站一边去，等它们读（读解锁）完你再来写（写锁定）。我们可以将其总结为如下三条：

1.  同时只能有一个 goroutine 能够获得写锁定。
2.  同时可以有任意多个 gorouinte 获得读锁定。
3.  同时只能存在写锁定或读锁定（读和写互斥）。

所以，RWMutex这个读写锁，该锁可以加多个读锁或者一个写锁，其经常用于读次数远远多于写次数的场景。

读写锁的写锁只能锁定一次，解锁前不能多次锁定，读锁可以多次，但读解锁次数最多只能比读锁次数多一次，一般情况下我们不建议读解锁次数多余读锁次数。

基本遵循两大原则：

1、可以随便读，多个goroutine同时读。

2、写的时候，啥也不能干。不能读也不能写。

读写锁即是针对于读写操作的互斥锁。它与普通的互斥锁最大的不同就是，它可以分别针对读操作和写操作进行锁定和解锁操作。读写锁遵循的访问控制规则与互斥锁有所不同。在读写锁管辖的范围内，它允许任意个读操作的同时进行。但是在同一时刻，它只允许有一个写操作在进行。

并且在某一个写操作被进行的过程中，读操作的进行也是不被允许的。也就是说读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间却不存在互斥关系。

### **二、常用方法** ###

#### **2.1、RLock()方法** ####

func (rw *RWMutex) RLock()

读锁，当有写锁时，无法加载读锁，当只有读锁或者没有锁时，可以加载读锁，读锁可以加载多个，所以适用于“读多写少”的场景。

![2a489eab468748e5b06048f2e5b3fd19.png][]

**2.2、RUnlock()方法**

func (rw *RWMutex) RUnlock()

读锁解锁，RUnlock 撤销单次RLock调用，它对于其它同时存在的读取器则没有效果。若rw并没有为读取而锁定，调用RUnlock就会引发一个运行时错误。

![e1722bd4505f4b1680119f629b7d6aa3.png][]

**2.3、Lock()方法：**

func (rw *RWMutex) Lock()

写锁，如果在添加写锁之前已经有其他的读锁和写锁，则Lock就会阻塞直到该锁可用，为确保该锁最终可用，已阻塞的Lock调用会从获得的锁中排除新的读取锁，即写锁权限高于读锁，有写锁时优先进行写锁定。

![9e7180783774dcc5815ac4618dc6464c.png][]

#### **2.4、Unlock()方法** ####

func (rw *RWMutex) Unlock()

写锁解锁，如果没有进行写锁定，则就会引起一个运行时错误。

![b514b47d0e244aed80240b5dbcbb2c5e.png][]

### **三、示例代码：** ###

示例代码：

package main
    
    import (
        "fmt"
        "sync"
        "time"
    )
    
    
    var rwMutex *sync.RWMutex
    var wg *sync.WaitGroup
    func main() {
        rwMutex = new(sync.RWMutex)
        wg = new (sync.WaitGroup)
    
        //wg.Add(2)
        //
        多个同时读取
        //go readData(1)
        //go readData(2)
    
        wg.Add(3)
        go writeData(1)
        go readData(2)
        go writeData(3)
    
        wg.Wait()
        fmt.Println("main..over...")
    }
    
    
    func writeData(i int){
        defer wg.Done()
        fmt.Println(i,"开始写：write start。。")
        rwMutex.Lock()//写操作上锁
        fmt.Println(i,"正在写：writing。。。。")
        time.Sleep(3*time.Second)
        rwMutex.Unlock()
        fmt.Println(i,"写结束：write over。。")
    }
    
    func readData(i int) {
        defer wg.Done()
    
        fmt.Println(i, "开始读：read start。。")
    
        rwMutex.RLock() //读操作上锁
        fmt.Println(i,"正在读取数据：reading。。。")
        time.Sleep(3*time.Second)
        rwMutex.RUnlock() //读操作解锁
        fmt.Println(i,"读结束：read over。。。")
    }

运行结果：

![61392bf00fe74341aa3f988e837dc4f4.png][]

GOROOT=/usr/local/go #gosetup
    GOPATH=/Users/ruby/go #gosetup
    /usr/local/go/bin/go build -i -o /private/var/folders/kt/nlhsnpgn6lgd_q16f8j83sbh0000gn/T/___go_build_demo07_rwmutex_go /Users/ruby/go/src/l_goroutine/demo07_rwmutex.go #gosetup
    /private/var/folders/kt/nlhsnpgn6lgd_q16f8j83sbh0000gn/T/___go_build_demo07_rwmutex_go #gosetup
    3 开始写：write start
    3 正在写：writing
    2 开始读：read start
    1 开始写：write start
    3 写结束：write over
    2 正在读：reading
    2 读结束：read over
    1 正在写：writing
    1 写结束：write over
    main..over...
    
    Process finished with exit code 0

最后概括：

1.  读锁不能阻塞读锁
2.  读锁需要阻塞写锁，直到所有读锁都释放
3.  写锁需要阻塞读锁，直到所有写锁都释放
4.  写锁需要阻塞写锁

[1ab708f8ccf14be69b873424f197f91b.png]: https://img-blog.csdnimg.cn/1ab708f8ccf14be69b873424f197f91b.png
[0fdf6a3411814344b324725f3eb79cfc.png]: https://img-blog.csdnimg.cn/0fdf6a3411814344b324725f3eb79cfc.png
[2a489eab468748e5b06048f2e5b3fd19.png]: https://img-blog.csdnimg.cn/2a489eab468748e5b06048f2e5b3fd19.png
[e1722bd4505f4b1680119f629b7d6aa3.png]: https://img-blog.csdnimg.cn/e1722bd4505f4b1680119f629b7d6aa3.png
[9e7180783774dcc5815ac4618dc6464c.png]: https://img-blog.csdnimg.cn/img_convert/9e7180783774dcc5815ac4618dc6464c.png
[b514b47d0e244aed80240b5dbcbb2c5e.png]: https://img-blog.csdnimg.cn/b514b47d0e244aed80240b5dbcbb2c5e.png
[61392bf00fe74341aa3f988e837dc4f4.png]: https://img-blog.csdnimg.cn/61392bf00fe74341aa3f988e837dc4f4.png