加入收藏 | 设为首页 | 会员中心 | 我要投稿 聊城站长网 (https://www.0635zz.com/)- 智能语音交互、行业智能、AI应用、云计算、5G!
当前位置: 首页 > 综合聚焦 > 编程要点 > 语言 > 正文

Go语言资源竞争问题怎么处理

发布时间:2023-07-15 14:20:23 所属栏目:语言 来源:
导读:这篇“Go语言中资源竞争问题怎么解决”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看
这篇“Go语言中资源竞争问题怎么解决”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“Go语言中资源竞争问题怎么解决”文章吧。
 
场景
 
我们现在需要对1~100求他们的阶乘,并将结果放到一个map中
 
1! = 1 = 1
 
2! = 1 * 2 = 2
 
3! = 1 * 2 * 3 = 6
 
4! = 1 * 2 * 3 * 4 = 24
 
5! = 1 * 2 * 3 * 4 * 5 = 120
 
...
 
{
 
    1: 1
 
    2: 2
 
    3: 6
 
    4: 24
 
    5: 120
 
    ...
 
}
 
代码实现
 
var factorialMap = make(map[int]int)
 
func Factorial(n int) {
 
    result := 1
 
    for i := 1; i <= n; i++ {
 
        result *= i
 
    }
 
    factorialMap[n] = result
 
}
 
func main() {
 
    for i := 1; i < 10; i++ {
 
        Factorial(i)
 
    }
 
    for k, v := range factorialMap {
 
        fmt.Printf("%d 的阶乘是%d\n", k, v)
 
    }
 
}
 
Go语言中资源竞争问题怎么解决
 
上述代码执行结果其实是没问题的,为什么会出现乱序呢?因为这是go语言中map其实就是乱序的,按照我们的理解,先存的先出,但是不好意思,Golang的map不是这样的。 上面执行也没什么问题啊,细心的同学可能发现了,这个版本的代码并没有用上并发,对吧。好接下来我们继续改进
 
并发实现
 
var factorialMap = make(map[int]int)
 
func Factorial(n int) {
 
    result := 1
 
    for i := 1; i <= n; i++ {
 
        result *= i
 
    }
 
    factorialMap[n] = result
 
}
 
func main() {
 
    for i := 1; i < 10; i++ {
 
        go Factorial(i)
 
    }
 
    for k, v := range factorialMap {
 
        fmt.Printf("%d 的阶乘是%d\n", k, v)
 
    }
 
}
 
Go语言中资源竞争问题怎么解决我们可以发现,并发版就是在调用计算阶乘函数的前面加上了一个go而已。不要小看这个go,扯远了,当然大家知道这是go语言中开启一个协程的关键字即可。
 
执行结果就是,控制台啥都没输出,这是因为主协程和子协程之间的执行关系,下面我们画图理解
 
Go语言中资源竞争问题怎么解决
 
从上图中我们可以发现,主协程执行的时间短(表现在比较短),子协程执行时间比较长(表现在比较长) 我们一定要记住,子协程是相对于当前的主协程来说的,如果主协程不存在了,那就没有子协程了
 
所以上面代码啥都没输出就是因为,主协程已经执行完了,但是子协程还没做完,那子协程都没做完,factorialMap中能有东西吗?
 
主等子
 
这就引出我们第一个问题,主协程如何等待子协程执行完再退出程序。我们现在用一个最简单,最容易想到的做法
 
var factorialMap = make(map[int]int)
 
func Factorial(n int) {
 
    result := 1
 
    for i := 1; i <= n; i++ {
 
        result *= i
 
    }
 
    factorialMap[n] = result
 
}
 
func main() {
 
    for i := 1; i < 100; i++ {
 
        go Factorial(i)
 
    }
 
    time.Sleep(time.Second * 3)
 
    for k, v := range factorialMap {
 
        fmt.Printf("%d 的阶乘是%d\n", k, v)
 
    }
 
}
 
Go语言中资源竞争问题怎么解决当并发数比较小的时候,这个问题可能不会出现,一旦并发数变大,问题就立马出现了
 
图中的执行结果是并发map写入错误为什么会出现这个问题,我们假设100个人往一个篮子里放水果,很容易。但是100个人从一个篮子里拿水果,那就会出问题,首先,篮子里的水果不一定够100个,其二每个人都想先拿,必然会引起争抢。
 
问题一优化
 
针对上面的问题,我们引入全局锁的概念。这就有点像我们上厕所,100个人都想上厕所,但厕所只有1个,谁先抢到了谁先上,并且这个人还有给厕所上锁,防止其他人进来
 
var factorialMap = make(map[int]int)
 
var lock sync.Mutex
 
func Factorial(n int) {
 
    result := 1
 
    for i := 1; i <= n; i++ {
 
            result *= i
 
    }
 
    // defer 不好理解
 
    // defer func(){
 
    // lock.Unlock() // 执行完解锁
 
    // }()
 
    lock.Lock() // 执行时上锁
 
    factorialMap[n] = result
 
    lock.Unlock() // 执行后解锁
 
}
 
func main() {
 
    for i := 1; i < 100; i++ {
 
        go Factorial(i)
 
    }
 
    time.Sleep(time.Second * 3)
 
    for k, v := range factorialMap {
 
        fmt.Printf("%d 的阶乘是%d\n", k, v)
 
    }
 
}
 
Go语言中资源竞争问题怎么解决执行结果有0可能是数据类型存不下了导致的,这个大家不用关心
 
Go语言中资源竞争问题怎么解决这样我们就解决了资源竞争的问题了。但其实还有一个问题,就是我们在主协程中还是必须手动等待,这要非常不好,那如果子协程3秒内解决不了怎么办?
 
问题二优化
 
这个问题是我们不想在主协程中手动等待子协程,换句话说是我们不想直接在代码中写明要等待多长时间
 
这里我们就引入了WaitGroup
 
var factorialMap = make(map[int]int)
 
var lock sync.Mutex
 
var wg sync.WaitGroup
 
func Factorial(n int) {
 
    result := 1
 
    for i := 1; i <= n; i++ {
 
        result *= i
 
    }
 
    lock.Lock() // 执行时上锁
 
    factorialMap[n] = result
 
    lock.Unlock() // 执行后解锁
 
    wg.Done()
 
}
 
func main() {
 
    for i := 1; i < 100; i++ {
 
        wg.Add(1)
 
        go Factorial(i)
 
    }
 
    wg.Wait()
 
    for k, v := range factorialMap {
 
        fmt.Printf("%d 的阶乘是%d\n", k, v)
 
    }
 
}
 
WaitGroup的内部原理大家自己细扣,我这就不讲了 总结来说就是WaitGroup是一个篮子,每开一个协程,就往篮子中加一个标识(Add函数),每执行完一个协程,就从篮子中减去一个标识(Done函数),最后查看篮子中,如果是空的,就表示协程执行完了(Wait函数)。
 
 

(编辑:聊城站长网)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!