您当前所在位置：首页 > 脚本专栏 > Golang

Golang

Go语言如何利用Mutex保障数据读写准确

[db:来源] 2023-05-11Golang5302

这篇文章主要介绍了互斥锁的实现机制，以及 Go 标准库的互斥锁 Mutex 的基本使用方法，文中的示例代码讲解具体，需要的小伙伴可以参考一下

Go 语言作为一个原生支持用户态入程（Goroutine）的语言，当提到并发编程、多线程编程时，去去都离不开锁这一概念。锁是一种并发编程中的同步原语（Synchronization Primitives），它能保证多个 Goroutine 在访问同一片内存时不会出现竞争条件（Race condition）等问题。

本文，我会带你具体了解互斥锁的实现机制，以及 Go 标准库的互斥锁 Mutex 的基本使用方法。后面会讲解 Mutex 的详细实现原理、易错场景和一些拓铺用法。欢迎关注一下不迷路。

好了，我们先来观观互斥锁的实现机制。

1、实现机制

互斥锁 Mutex 是并发控制的一个基本手段，是为了避免并发竞争建立的并发控制机制，其中有个“临界区”的概念。

在并发编程过程中，假如程序中一部分资源或者变量会被并发访问或者修改，为了避免并发访问导致数据的不正确，这部分程序需要率先被保护起来，之后操作，操作结束后往除保护，这部分被保护的程序就鸣做 临界区。

限定临界区只能同时由一个线程持有。 当临界区由一个线程持有的时候，其它线程假如想入进这个临界区，就会返归失败，或者是等待。直到持有的线程退出临界区，其他线程才有机会获得这个临界区。如下图：

Go mutex 临界区示意图

上图互斥锁就很好地解决了资源竞争问题，有人也把互斥锁鸣做排它锁。那在 Go 标准库中，它提供了 Mutex 来实现互斥锁这个功能。

Go 语言在 sync 包中提供了用于同步的一些基本原语，包括常见的 sync.Mutex、sync.RWMutex、sync.WaitGroup、sync.Once 和 sync.Cond。这次主要讲 Mutex。

接下来我们观观到底可以怎么使用 Mutex。

2、基本用法

在 Go 的标准库中，package sync 提供了锁相关的一系列同步原语，这个 package 还定义了一个 Locker 的接口，Mutex 就实现了这个接口。

互斥锁 Mutex 提供了两个方法 Lock 和 Unlock：入进到临界区使用 Lock 方法加锁，退出临界区使用 Unlock 方法释放锁。

type Locker interface {
    Lock()
    Unlock()
}

上面可以观出，Go 定义的锁接口的方法集很简朴，就是哀求锁（Lock）和释放锁（Unlock）这两个方法，继续了 Go 语言一贯的简洁风格。

我们本文会介绍的 Mutex 以及后面会介绍的读写锁 RWMutex 都实现了 Locker 接口，所以首先我把这个接口介绍了，提前了解一下。

func(m *Mutex)Lock()
func(m *Mutex)Unlock()

并发场景下，一个 goroutine 调用 Lock 方法拿到锁后，此时其他的 goroutine 会阻塞在 Lock 的调用上，一直等到当前获取到锁的 goroutine 释放锁。

观到这儿，你可能会问，为啥一定要加锁呢？那我们就说一下在并发场景下不使用锁的例子，观下会出现什么问题。

举一个计数器的例子，是由 10 个 goroutine 对计数器入行累加操作，每个 goroutine 负责执行 10 万次的加 1 操作，期望的结果是 1000000 （10 * 100000）。

package main
import (
    "fmt"
    "sync"
)
    
func main() {
    var count = 0
    // 使用 WaitGroup 等待,创建 10 个goroutine
    var wg sync.WaitGroup
    wg.Add(10)
    for i := 0; i< 10;i++ {
        go func() {
            defer wg.Done()
            // 对变量count执行10次加1
            for j := 0; j< 100000; j++ {
                count++
            }
        }()
    }
    // 等待 10个 goroutine完成
    wg.Wait()
    fmt.Printin("count:", count)
}

每次运行，都得到了不同的结果，所以是不会得到期望的 1000000。

那么这是为什么？

其实，因为 count++ 不是一个原子操作，就可能有并发的问题。

上述是并发访问共享数据的常见错误，10 个 goroutine 同时读取到 count 的值为 9867，对值加 1，值变成啦9868，然后把这个值覆盖到 count，但是实际上此时我们增加的总数应该是 10 才对，这里却只增加了 1，好多计数都被“吞”掉了。

3、race detector

很多时候，并发问题隐躲得非常深，即使是有经验的人，也不太轻易发现或者 Debug 出来。

Go race detector ， 一个检测并发访问共享资源是否有问题的工具，它可以帮助我们自动发现程序有没有 data race 的问题。是基于 Google 的 C/C++ sanitizers 技术实现的，能够监测出内存地址的访问，当代码运行时，race detector 可以很好的监控到共享变量的非同步访问，出现 race 的时候，能够输出警告的信息。

怎么用的呢？

在编译、测试、运行 Go 代码的时候，加上 race 参数，就有可能发现并发问题。比如在上面的例子中，我们可以加上 race 参数运行，检测一下是不是有并发问题。

go run -race main.go 就会输出警告信息。

图中会提示有并发问题，会提示哪一个 goroutine 在某一行对变量有写操作，同时也会提示哪个 goroutine 在某一行对变量有读操作，这就是并发操作时引起了 data race。

既然存在 data race 问题，我们怎么往解决呢？接下来就讲下 Mutex，它可以轻松地消除掉 data race。

package main
import (
    "fmt"
    "sync"
)
    
func main() {
    var count = 0
    
    // 互斥锁保护计数器
    var mu sync.Mutex
    // 辅助变量，用来确认所有的goroutine都完成
    var wg sync.WaitGroup
    wg.Add(10)
    // 启动10个gourontine
    for i := 0;i< 10;i+++ {
        go func() {
            defer wg.Done()
            for j := 0; j< 100000; j++ {
                mu.Lock()
                count++
                mu.Unlock()
            }
        }()
    }
    // 等待 10个 goroutine完成
    wg.Wait()
    fmt.Printin("count:", count)
}

运行一下 go run -race main.go

你会发现输出了期望值 1000000，data race 告警也没有啦。

怎么样，是不是很惊喜，使用 Mutex 是不是非常高效？

我们在日常使用中，Mutex 会嵌进到其它 struct 中使用。

type Counter struct{
    sync.Mutex
    Count uint64
}


func main() {
    var counter Counter
    var wg sync.WaitGroup
    wg.Add(10)
    for i := 0;i< 10;i++ {
        go func() {
            defer wg.Done()
            for j := 0; j < 100000; j++ {
                counter.Lock()
                counter.Count++
                counter.Unlock()
            }
        }()
    }
    wg.Wait()
    fmt.Println("count:", counter.Count)
}

当嵌进的 struct 有多个字段，我们会把 Mutex 放在要控制的字段上面，然后使用空格把字段分隔开来。这样写的话，逻辑会更清楚，也更易于维护。

有时候，你还可以把获取锁、释放锁、计数加一的逻辑封装成一个方法，对外不需要暴露锁等逻辑。

//线程安全的计数器类型
type Counter struct{
    CounterType int
    Name        string
    mu    sync.Mutex
    count uint64
}

func main() {
    // 封装一个计数器
    var counter Counter
    var wg sync.WaitGroup
    wg.Add(10)
    // 启动 10 个 goroutine
    for i := 0;i< 10;i++ {
        go func() {
            defer wg.Done( )
            // 执行 10 万次累加
            for j := 0; j< 100000; j++ {
                // 受到锁保护的方法
                counter.Incr()
            }
        }()
    }
    wg.Wait()
    fmt.PrintIn(counter.Count())
}

// 加1的方法，内部使用互斥锁保护
func (c *Counter) Incr() {
    c.mu.Lock()
    c.count++
    c.mu.Unlock()
}
// 得到计数器的值，也需要锁保护
func (c *Counter) Count() uint64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}