索引:https://www.waterflow.link/articles/1666884810643

当我们打印错误的时候使用锁可能会带来意想不到的结果。

我们看下面的例子:

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))
}

上面的代码看起来貌似没有什么问题,但是却会导致死锁:

  1. 更新课件时长的时候上锁,避免出现数据竞争
  2. 判断如果时长小于60秒的话,就报错。但是注意这里fmt.Errorf打印结构c会调用String()方法
  3. 我们看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)
}()
}
  1. 我们给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)
}
  1. 我们有一个用户的机构,里面有个online字段是一个map,里面保存了在线的用户信息
  2. 我们有一个添加在线用户的方法AddOnline,方法里面使用了锁,是因为map是并发不安全的
  3. 我们还有一个统计所有在线用户的方法AllOnline
  4. 在AllOnline中,我们访问u.online的map,我们加上了读锁。这里的想法是访问当前在线用户的map,并赋值给online,然后释放读锁
  5. 遍历赋值的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中的锁竞争问题的更多相关文章

  1. golang中锁mutex的实现

    golang中的锁是通过CAS原子操作实现的,Mutex结构如下: type Mutex struct {     state int32                     sema  uint ...

  2. BP-Wrapper:无锁竞争的缓存替换算法系统框架

    BP-Wrapper:无锁竞争的替换算法系统框架 最近看了一个golang的高性能缓存ristretto,该缓存可以很好地实现如下功能: Concurrent High cache-hit ratio ...

  3. Linux中自旋锁

    传统的spinlock Linux的的内核最常见的锁是自旋锁.自旋锁最多只能被一个可执行线程持有.如果一个执行线程试图获得一个被已经持有(争用)的自旋锁,那么该线程就会一直进行忙循环-旋转-等待锁重新 ...

  4. 【协作式原创】查漏补缺之Golang中mutex源码实现(预备知识)

    预备知识 CAS机制 1. 是什么 参考附录3 CAS 是项乐观锁技术,当多个线程尝试使用 CAS 同时更新同一个变量时,只有其中一个线程能更新变量的值,而其它线程都失败,失败的线程并不会被挂起,而是 ...

  5. golang 中 sync.Mutex 的实现

    mutex 的实现思想 mutex 主要有两个 method: Lock() 和 Unlock() Lock() 可以通过一个 CAS 操作来实现 func (m *Mutex) Lock() { f ...

  6. java中的锁

    java中有哪些锁 这个问题在我看了一遍<java并发编程>后尽然无法回答,说明自己对于锁的概念了解的不够.于是再次翻看了一下书里的内容,突然有点打开脑门的感觉.看来确实是要学习的最好方式 ...

  7. golang中的race检测

    golang中的race检测 由于golang中的go是非常方便的,加上函数又非常容易隐藏go. 所以很多时候,当我们写出一个程序的时候,我们并不知道这个程序在并发情况下会不会出现什么问题. 所以在本 ...

  8. Dom4j 锁竞争性能低下解决

    在最近的项目中使用 Dom4j 解析 xml 发现性能低下,有锁竞争的情况,解决如下: SAXParserFactory factory = new org.apache.xerces.jaxp.SA ...

  9. 多线程 (三)iOS中的锁

    锁的类别:互斥锁,递归锁,条件锁,自旋锁等 锁的实现方式:NSLock,NSRecursiveLock, NSConditionLock,@synchronized,GCD的信号量等 下面说一下常用的 ...

随机推荐

  1. MySQL8.0解决“MySQL 服务无法启动。 服务没有报告任何错误。”

    TL;NRs 初始化服务时最好使用mysqld --initialized --console命令: MySQL8.0的配置变量与MySQL5.7不同,[mysqld]下面设置字符集的变量名为char ...

  2. LuoguP1858 多人背包(DP)

    第\(K\)优解这类问题可在\(DP\)过程中通过添维解决.归并出当前前\(K\)大的解. #include <iostream> #include <cstdio> #inc ...

  3. Windows 电脑杀毒简单有效的方式

    Windows 电脑杀毒通常会选择杀毒软件,这样太笨重,且容易占内存和存在流氓软件侵入. 推荐使用 Windows 自带的恶意软件删除工具 按住 Win + R 键,弹出运行窗口,输入 mrt. 系统 ...

  4. UI自动化框架搭建之Python3

    UI自动化框架搭建--unittest 使用的代码是Python3版本,与时俱进哈哈 解释一下我的框架目录接口(每个人框架的目录接口不一样,根据实际要求) common目录:公共模块,这个地方可以存放 ...

  5. 痞子衡嵌入式:浅析IAR下调试信息输出机制之硬件UART外设

    大家好,我是痞子衡,是正经搞技术的痞子.今天痞子衡给大家分享的是IAR下调试信息输出机制之硬件UART外设. 在嵌入式世界里,输出打印信息是一种非常常用的辅助调试手段,借助打印信息,我们可以比较容易地 ...

  6. 网安等保-Linux服务器之最新Ubuntu-22.04-LTS系统内核优化与安全加固配置脚本使用分享

    关注「WeiyiGeek」公众号 设为「特别关注」每天带你玩转网络安全运维.应用开发.物联网IOT学习! 希望各位看友[关注.点赞.评论.收藏.投币],助力每一个梦想. 本章目录 目录 0x00 前言 ...

  7. 回溯、贪心、DP的区别和联系

    四大常用算法:分治.贪心.回溯.动态规划 回溯算法是个"万金油".基本上能用跟动态规划.贪心解决的问题,都可以用回溯去解决.回溯算法相当于穷举搜索,穷举所有情况,然后得到最优解.不 ...

  8. java数组---稀疏数组与数组之间的相互转化

    public static void main(String[] args) { int[][]array1=new int[11][11]; array1[1][2]=1; array1[2][3] ...

  9. 「题解报告」P3354

    P3354 题解 题目传送门 一道很恶心的树形dp 但是我喜欢 题目大意: 一片海旁边有一条树状的河,入海口有一个大伐木场,每条河的分叉处都有村庄.建了伐木场的村庄可以直接处理木料,否则要往下游的伐木 ...

  10. 「题解报告」CF1067A Array Without Local Maximums

    大佬们的题解都太深奥了,直接把转移方程放出来让其他大佬们感性理解,蒟蒻们很难理解,所以我就写了一篇让像我一样的蒟蒻能看懂的题解 原题传送门 动态规划三部曲:确定状态,转移方程,初始状态和答案. --神 ...