go语言并发编程-超详细mutex解析

news2024/9/21 10:42:42

文章目录

1 go语言并发编程学习-mutex
- 1.1 学习过程
- 1.2 如何解决资源并发访问的问题？【基本用法】
- - 1.2.1 并发访问带来的问题
  - - 1.2.1.1 导致问题的原因
  - 1.2.2 race detector检查data race
  - 1.2.3 mutex的基本实现机制以及使用方法
  - - 1.2.3.1 具体使用-1
    - 1.2.3.1 具体使用-2

1 go语言并发编程学习-mutex

1.1 学习过程

在这里插入图片描述

1.2 如何解决资源并发访问的问题？【基本用法】

本小节主要为了解答以下问题：

为什么需要解决并发访问的问题？
怎么通过race detector来查找程序中的data race？
mutex的基本机制和基本使用方法？

1.2.1 并发访问带来的问题

1. 多个goroutine并发更新计数器

在多个goroutine的情况下并发更新计数器，得到的值可能不符合预期。

package main

import (
    "fmt"
    "sync"
)

var counter int
var wg sync.WaitGroup

func increment() {
    defer wg.Done()
    counter += 100
}

func main() {
    wg.Add(1000) // 这个可以先不管，理解为，main函数需要等待goroutine都执行完才能退出，可以把wg相关全去掉，在main函数后面加上time.sleep(time.second * 10)
    for i := 0; i < 1000; i++ {
       go increment()
    }
    wg.Wait()
    fmt.Println("Final counter:", counter) // 期望输出 2，但可能输出 0 或 1
}

2. 更新用户的账户余额

在用户收入和支出的时候，如果不同的goroutine同时对该账户余额进行更新处理的时候，可能会导致余额错误

package main

import (
    "fmt"
    "sync"
)

var balance int = 1000
var wg sync.WaitGroup

func deposit(amount int) {
    defer wg.Done()
    balance += amount
}

func withdraw(amount int) {
    defer wg.Done()
    balance -= amount
}

func main() {
    wg.Add(2000)
    for i := 0; i < 1000; i++ {
       go deposit(1)
       go withdraw(1)
    }
    wg.Wait()
    fmt.Println("Final balance:", balance) // 期望输出 1000，但可能输出其他值
}

3. 秒杀系统

没有互斥锁的情况下，可能会出现超卖的情况。也就是商品已经没有了，但是还是可以进行出售商品，商品数量减1的操作。

package main

import (
    "fmt"
    "sync"
)

var stock int = 10
var wg sync.WaitGroup

func purchase() {
    defer wg.Done()
    if stock > 0 {
       fmt.Println("Stock:", stock)
       stock--
    }
}

func main() {
    wg.Add(100000)
    for i := 0; i < 100000; i++ {
       go purchase()
    }
    wg.Wait()
    fmt.Println("Final stock:", stock) // 期望输出 0，但可能输出负数
}

还有一些其他的场景，比如并发写入buffer等等，不解决并发访问的问题，就会发生很严重的后果。

1.2.1.1 导致问题的原因

并发访问问题的核心在于对共享资源的非原子性操作。临界区是指一段需要独占访问的代码块，多个goroutine在执行这段代码时，如果没有同步机制（如互斥锁）来保证互斥访问，就可能会产生数据竞争，导致数据不一致和其他问题。以下从临界区的角度来解释这些问题。下面分析多个goroutine并发更新计数器：

计数器的更新操作通常包括以下步骤：

读取当前计数器的值
对读取的值进行加法运算
将结果写回计数器

在并发情况下，如果两个goroutine同时执行这三个步骤中的任意一个步骤，没有同步机制来保证这三个步骤是原子操作，就会产生问题：

Goroutine 1: 读取 counter = 0
Goroutine 2: 读取 counter = 0
Goroutine 1: counter = 0 + 1 => counter = 1
Goroutine 2: counter = 0 + 1 => counter = 1 （覆盖了Goroutine 1的结果）

那么怎么在程序运行的时候发现呢？可以参考一下race detector工具

1.2.2 race detector检查data race

可以使用上文的秒杀系统作为例子。写这个的时候，图片转存失败，因此决定用极客上的图片。
1、在执行go run counter.go的时候会出现以下结果，是可以正常运行通过的，但是结果不如愿：
在这里插入图片描述
2、但是假如race之后：go run -race main.go

这个警告不但会告诉你有并发问题,而且还会告诉你哪个goroutiine在哪一行对哪个变量有写操作,同时,哪个goroutine在哪一行对哪个变量有读操作,就是这些并发的读写访问,引起了datarace。
例子中的goroutine 10 对内存地址0x000126010有读的操作(ctounter.go文件第16行),同时,goroutine7对内存地址0x00c000126010有写的操作(counter.go文件第16行)。而且还可能有多个goroutine在同时进行读写,所以,警告信息可能会很长。

总结一下,通过在编译的时候插入一些指令,在运行时通过这些插入的指令检测并发读写从而发现data race问题,就是这个工具的实现机制。
既然这个例子存在data race问题,我们就要想办法来解决它。这个时候,我们这节课的主角Mutex就要登场了,它可以轻松地消除掉data race。
具体怎么做呢?下面,我就结合这个例子,来具体说一说Mutex的基本用法。

1.2.3 mutex的基本实现机制以及使用方法

在这里插入图片描述
mutex的基本实现的机制，就是每次只允许一个goroutine进入临界区，具体就是进入临界区的时候给临界区加上一个锁，禁止其他goroutine进入临界区，在退出临界区的时候释放锁，从而允许其他goroutine进入。

Mutex 是 Go 语言中常用的同步原语，用于控制对共享资源的独占访问。Mutex 实现了 sync.Locker 接口，该接口定义了两个方法：Lock 和 Unlock。在解释 Mutex 的基本使用方法之前，先简单介绍一下 sync.Locker 接口：

type Locker interface {    
	Lock()    
	Unlock() 
}

任何实现了 Lock 和 Unlock 方法的类型，都可以被视为 Locker，所以 sync.Mutex 也实现了这个接口。以下是一个基本的 sync.Mutex 的使用方法：

1、基本使用方法：

声明一个sync.Mutex类型的变量，无需初始化

var mutex sync.Mutex

2、在需要保护的临界区前调用 Lock 方法：

mutex.Lock()

3、在临界区结束后调用 Unlock 方法：

mutex.Unlock()

1.2.3.1 具体使用-1

这种使用，主要是在临界区代码中直接使用mutex即可。

package main

import (
    "fmt"
    "sync"
)

var stock int = 10
var wg sync.WaitGroup
var mutex sync.Mutex

func purchase() {
    defer wg.Done()
    mutex.Lock()         // 加锁，进入临界区
    defer mutex.Unlock() // 确保解锁
    if stock > 0 {
       fmt.Println("Stock:", stock)
       stock--
    }
}

func main() {
    wg.Add(100000)
    for i := 0; i < 100000; i++ {
       go purchase()
    }
    wg.Wait()
    fmt.Println("Final stock:", stock) // 期望输出 0，但可能输出负数
}

1.2.3.1 具体使用-2

该使用是把mutex和临界区资源封装为一个类，这样更好的进行复用，不暴露内部实现

package main

import (
    "fmt"
    "sync"
)

// StockManager 结构体封装了库存和互斥锁
type StockManager struct {
    stock int
    mutex sync.Mutex
}

// NewStockManager 创建一个新的 StockManager
func NewStockManager(initialStock int) *StockManager {
    return &StockManager{stock: initialStock}
}

// Purchase 尝试购买一个商品
func (sm *StockManager) Purchase() bool {
    sm.mutex.Lock()
    defer sm.mutex.Unlock()

    if sm.stock > 0 {
       sm.stock--
       fmt.Println("Purchase successful, remaining stock:", sm.stock)
       return true
    }
    fmt.Println("Purchase failed, out of stock")
    return false
}

// GetStock 获取当前库存
func (sm *StockManager) GetStock() int {
    sm.mutex.Lock()
    defer sm.mutex.Unlock()
    return sm.stock
}

func main() {
    sm := NewStockManager(10)
    var wg sync.WaitGroup

    numUsers := 100000
    wg.Add(numUsers)
    for i := 0; i < numUsers; i++ {
       go func() {
          defer wg.Done()
          sm.Purchase()
       }()
    }
    wg.Wait()
    fmt.Println("Final stock:", sm.GetStock())
}