解析Golang中的锁竞争问题
更新时间：2022年10月28日 08:16:27 作者：liuyuede123
这篇文章主要介绍了golang中的锁竞争问题,本文通过实例代码给大家详细讲解，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
当我们打印错误的时候使用锁可能会带来意想不到的结果。
我们看下面的例子：
package main
import (
"fmt"
"sync"
)
type Courseware struct {
mutex sync.RWMutex
Id int64
Code string
Duration int
}
func (c *Courseware) UpdateDuration(duration int) error {
c.mutex.Lock() // 1
defer c.mutex.Unlock()
if duration < 60 {
return fmt.Errorf("课件时长必须大于等于60秒： %v", c) // 2
}
c.Duration = duration
return nil
}
// 3
func (c *Courseware) String() string {
c.mutex.RLock()
defer c.mutex.RUnlock()
return fmt.Sprintf("id %d, duration %d", c.Id, c.Duration)
}
func main() {
c := &Courseware{}
fmt.Println(c.UpdateDuration(0))
}
上面的代码看起来貌似没有什么问题，但是却会导致死锁：
- 更新课件时长的时候上锁，避免出现数据竞争
- 判断如果时长小于60秒的话，就报错。但是注意这里fmt.Errorf打印结构c会调用String()方法
- 我们看String方法里面，又使用了读锁，避免读取的时候数据被更新
因为对临界资源重复上锁，所以导致了死锁的问题。解决办法也很简单：
- 把锁放到错误判断之后：
func (c *Courseware) UpdateDuration(duration int) error {
if duration < 60 {
return fmt.Errorf("课件时长必须大于等于60秒： %v", c) // 2
}
c.mutex.Lock()
defer c.mutex.Unlock()
c.Duration = duration
return nil
}
- 不使用String方法，避免重复上锁：
package main
import (
"fmt"
"sync"
)
type Courseware struct {
mutex sync.RWMutex
Id int64
Code string
Duration int
}
func (c *Courseware) UpdateDuration(duration int) error {
c.mutex.Lock()
defer c.mutex.Unlock()
if duration < 60 {
return fmt.Errorf("课件时长必须大于等于60秒： %d， id: %d", c.Duration, c.Id) // 打印放在一个锁里面也能保证安全
}
c.Duration = duration
return nil
}
func main() {
c := &Courseware{}
fmt.Println(c.UpdateDuration(0))
}
go run 10.go 课件时长必须大于等于60秒： 0， id: 0
我们再看一个切片的例子：
package main
import (
"fmt"
)
func main() {
s := make([]int, 1)
go func() {
s1 := append(s, 1)
fmt.Println(s1)
}()
go func() {
s2 := append(s, 1)
fmt.Println(s2)
}()
}
我们初始化了一个长度为1，容量为1的切片，然后分别在2个协程里面调用append往切片追加元素。这种情况会导致数据竞争么？
答案是不会。在其中一个协程里面，当我们append元素的时候，因为s的容量为1，所以底层会复制一个新的数组；同样另一个协程也是如此。
go run -race 10.go [0 1] [0 1]
注意：这里的关键就是，两个协程是否会同时访问一个内存空间，这时导致数据竞争的关键。
我们稍微修改下上面的例子：
package main
import (
"fmt"
)
func main() {
s := make([]int, 1, 10) // 1
go func() {
s1 := append(s, 1)
fmt.Println(s1)
}()
go func() {
s2 := append(s, 1)
fmt.Println(s2)
}()
}
- 我们给s加了一个足够大的容量
go run -race 10.go [0 1] ================== WARNING: DATA RACE Write at 0x00c0000c0008 by goroutine 8: main.main.func2() ...
可以看到这就产生了数据竞争的问题。因为s的容量足够大，所以两个协程有可能操作同一个底层数组的同一块内存。
解决办法也很简单，重新copy一个s就行了。
下面我们继续看一个map的例子：
package main
import (
"strconv"
"sync"
"time"
)
// 1
type User struct {
mu sync.RWMutex
online map[string]bool
}
// 2
func (u *User) AddOnline(id string) {
u.mu.Lock()
u.online[id] = true
u.mu.Unlock()
}
// 3
func (u *User) AllOnline() int {
u.mu.RLock()
online := u.online // 4
u.mu.RUnlock()
sum := 0
for _, o := range online { // 5
if o {
sum++
}
}
return sum
}
func main() {
u := &User{}
u.online = make(map[string]bool)
go func() {
for i := 0; i < 10000; i++ {
u.AddOnline("userid" + strconv.Itoa(i))
}
}()
go func() {
for i := 0; i < 10000; i++ {
u.AllOnline()
}
}()
time.Sleep(time.Second)
}
- 我们有一个用户的机构，里面有个online字段是一个map，里面保存了在线的用户信息
- 我们有一个添加在线用户的方法AddOnline，方法里面使用了锁，是因为map是并发不安全的
- 我们还有一个统计所有在线用户的方法AllOnline
- 在AllOnline中，我们访问u.online的map，我们加上了读锁。这里的想法是访问当前在线用户的map，并赋值给online，然后释放读锁
- 遍历赋值的online查出在线用户的数量
可能我们觉得这个是没问题的，但是当我们运行程序的时候会发现这里存在数据竞争：
go run -race 10.go ================== WARNING: DATA RACE Write at 0x00c0000a0060 by goroutine 6: runtime.mapassign_faststr() ... ================== fatal error: concurrent map iteration and map write
这是因为，在map内部，是hmap结构，主要包含元数据（例如，计数器）和引用数据桶的指针。 因此，online := u.online 不会复制实际数据，而是复制的指针，实际操作的还是同一片内存。
解决这个问题也不难：
- 我们可以把锁的范围扩大，像下面这样：
func (u *User) AllOnline() int {
u.mu.RLock()
defer u.mu.RUnlock()
online := u.online
sum := 0
for _, o := range online {
if o {
sum++
}
}
return sum
}
- 另一种方法就是复制一个副本出来，像上面我们说的切片一样：
func (u *User) AllOnline() int {
u.mu.RLock()
online := make(map[string]bool, len(u.online))
for s, b := range u.online {
online[s] = b
}
u.mu.RUnlock()
sum := 0
for _, o := range online {
if o {
sum++
}
}
return sum
}
上面的例子中我们使用了*User定义了2个方法：
func (u *User) AddOnline(id string) {
u.mu.Lock()
u.online[id] = true
u.mu.Unlock()
}
func (u *User) AllOnline() int {
u.mu.RLock()
online := make(map[string]bool, len(u.online))
for s, b := range u.online {
online[s] = b
}
u.mu.RUnlock()
sum := 0
for _, o := range online {
if o {
sum++
}
}
return sum
}
我现在我们稍微修改下上面的列子：
package main
import (
"strconv"
"sync"
"time"
)
type User struct {
mu sync.RWMutex
online map[string]bool
}
func (u User) AddOnline(id string) {
u.mu.Lock()
u.online[id] = true
u.mu.Unlock()
}
func (u User) AllOnline() int {
u.mu.RLock()
online := make(map[string]bool, len(u.online))
for s, b := range u.online {
online[s] = b
}
u.mu.RUnlock()
sum := 0
for _, o := range online {
if o {
sum++
}
}
return sum
}
func main() {
u := User{}
u.online = make(map[string]bool)
go func() {
for i := 0; i < 10000; i++ {
u.AddOnline("userid" + strconv.Itoa(i))
}
}()
go func() {
for i := 0; i < 10000; i++ {
u.AllOnline()
}
}()
time.Sleep(time.Second)
}
现在我们直接使用User结构体定义这两个方法，但是当我们执行程序的时候，报了数据竞争的错误：
go run -race 10.go ================== WARNING: DATA RACE Read at 0x00c00011e060 by goroutine 7: main.User.AllOnline()
这个又是什么原因造成的呢？这是因为，当我门使用User作为参数时，直接复制了User的副本，因此sync.RWMutex也会被复制。
因为锁被复制了，所以对于同一个临界资源，处于不同锁的读写操作可以同时访问。
到此这篇关于golang中的锁竞争问题的文章就介绍到这了,更多相关go锁竞争内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
Go语言使用ioutil.ReadAll函数需要注意基本说明
这篇文章主要为大家介绍了Go语言使用ioutil.ReadAll函数需要注意基本说明，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪2023-07-07
这篇文章主要为大家详细介绍了学习Go语言时需要了解的interface{}注意事项，文中的示例代码讲解详细，感兴趣的小伙伴可以跟随小编一起了解一下2023-03-03
这篇文章主要介绍了Golang中优秀的消息队列NSQ基础安装及使用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-12-12
Go使用Google Gemini Pro API创建简单聊天机器人
这篇文章主要为大家介绍了Go使用Google Gemini Pro API创建简单聊天机器人实现过程详解,本文将通过最新的gemini go sdk来实现命令行聊天机器人2023-12-12
Golang中函数(Function)和方法(Method)的区别详解
在Golang中，大家必然会频繁使用到函数（Function）和方法（Method），但是有的同学可能并没有注意过函数和方法的异同点，函数和方法都是用来执行特定任务的代码块，虽然很相似，但也有很大的区别，所以本文将详细讲解函数和方法的定义以及它们的异同点2023-07-07
RPC（Remote Procedure Call），主要是帮助我们屏蔽网络编程细节 ，使我们更专注于业务逻辑，所以本文主要来和大家聊聊RPC的原理与简单调用，希望对大家有所帮助2023-05-05
这篇文章主要介绍了使用Go实现健壮的内存型缓存,本文比较了字节缓存和结构体缓存的优劣势，介绍了缓存穿透、缓存错误、缓存预热、缓存传输、故障转移、缓存淘汰等问题，并对一些常见的缓存库进行了基准测试，需要的朋友可以参考下2022-05-05
这篇文章主要介绍了Go语法的基本概念,本文讲解了Golang的基本知识、基础语法、相关术语等,需要的朋友可以参考下，希望能帮助到你2021-07-07
这篇文章主要介绍了Go语言函数基本用法,结合实例形式分析了Go语言函数的格式、定义、使用方法与相关注意事项,需要的朋友可以参考下2016-07-07
做开发的同学应该经常听到过负载均衡的概念，今天我们就来实现一个乞丐版的四层负载均衡，并用它对mysql进行负载均衡测试，感兴趣的可以了解一下2023-07-07
最新评论