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

目录

• 1、实现机制
• 2、基本用法
• 3、race detector
• 4、总结
• 5、思考问题

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
}

4、总结

本文介绍了并发问题的背景知识、标准库中 Mutex 的使用，通过 Go race detector 工具发下并发场景下的问题及解决方法。你肯定已经了解了 Mutex 这个同步原语。

日常开发中，在设计阶段，我们就应该需要考虑共享资源的并发问题，当然在初始阶段有时候并不是很确定某个资源时否会呗共享，会随着后续的迭代会显现。虽迟但会到。当你意识到这个问题时，就需要通过互斥锁来解决啦。

其实 Docker issue 37583、35517、32826、30696等、kubernetes issue 72361、71617等，都是后来发现的 data race 而采用互斥锁 Mutex 进行修复的。

5、思考问题

Q: 当 Mutex 已经被一个 goroutine 获取了锁，其它的 goroutine 们只能一直等待。当这个锁释放后，等待中的 goroutine 中哪一个会优先获取 Mutex 呢？

到此这篇关于Go语言如何利用Mutex保障数据读写正确的文章就介绍到这了,更多相关Go语言Mutex保障数据读写正确内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！