本文主要是介绍go语言并发编程-超详细mutex解析,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
文章目录
- 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 mainimport ("fmt""sync"
)var counter int
var wg sync.WaitGroupfunc 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 mainimport ("fmt""sync"
)var balance int = 1000
var wg sync.WaitGroupfunc 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 mainimport ("fmt""sync"
)var stock int = 10
var wg sync.WaitGroupfunc 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 mainimport ("fmt""sync"
)var stock int = 10
var wg sync.WaitGroup
var mutex sync.Mutexfunc 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 mainimport ("fmt""sync"
)// StockManager 结构体封装了库存和互斥锁
type StockManager struct {stock intmutex 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.WaitGroupnumUsers := 100000wg.Add(numUsers)for i := 0; i < numUsers; i++ {go func() {defer wg.Done()sm.Purchase()}()}wg.Wait()fmt.Println("Final stock:", sm.GetStock())
}
下一篇:mutex的原理以及常见的错误。
这篇关于go语言并发编程-超详细mutex解析的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!