go 全局变量互斥锁

╰+攻爆jí腚メ 2021-07-24 12:04 419阅读 0赞

# 一 需求 #

现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到 map 中，最后显示出来，要求使用 goroutine 完成。

# 二 分析 #

a 使用 goroutine 来完成，效率高，但是会出现并发/并行安全问题。

b 这里就提出了不同 goroutine 如何通信的问题。

c 使用 goroutine 来完成，看看使用 gorotine 并发完成会出现什么问题?

d 在运行某个程序时，如何知道是否存在资源竞争问题？方法很简单，在编译该程序时，增加一个参数 -race 即可。

# 三 代码 #

package main
    
    import (
       "fmt"
       "sync"
       _ "time"
    )
    
    // 思路
    // 1 编写一个函数，来计算各个数的阶乘，并放入到 map中。
    // 2 启动多个协程，统计结果放入到 map 中。
    // 3 map 应该做成一个全局的。
    
    var (
       myMap = make(map[int]int, 1)
       // 声明一个全局的互斥锁
       // lock：一个全局的互斥锁。
       // sync：包，用于同步（synchornized）。
       // Mutex：互斥
       lock sync.Mutex
    )
    
    // test 函数就是计算 n!, 并将这个结果放入到 myMap 中。
    func test(n int) {
       res := 1
       for i := 1; i <= n; i++ {
          res *= i
       }
       // 将 res 放入到 myMap。
       // 加锁
       lock.Lock()
       myMap[n] = res // concurrent map writes
       // 解锁
       lock.Unlock()
    }
    
    func main() {
       // 开启多个协程完成这个任务
       for i := 1; i <= 20; i++ {
          go test(i)
       }
    
       // 休眠10秒钟，不是一个好的解决方案
       // time.Sleep(time.Second * 5)
       // 输出结果,遍历这个结果
       lock.Lock()
       for i, v := range myMap {
          fmt.Printf("map[%d]=%d\n", i, v)
       }
       lock.Unlock()
    }

# 四 测试结果 #

> map\[8\]=40320
> 
> map\[10\]=3628800
> 
> map\[18\]=6402373705728000
> 
> map\[2\]=2
> 
> map\[6\]=720
> 
> map\[7\]=5040
> 
> map\[9\]=362880
> 
> map\[11\]=39916800
> 
> map\[15\]=1307674368000
> 
> map\[17\]=355687428096000
> 
> map\[1\]=1
> 
> map\[3\]=6
> 
> map\[13\]=6227020800
> 
> map\[19\]=121645100408832000
> 
> map\[4\]=24
> 
> map\[5\]=120
> 
> map\[16\]=20922789888000
> 
> map\[12\]=479001600
> 
> map\[14\]=87178291200

# 五 示意图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70][]

# 六 小结 #

这里使用了全局变量互斥锁来解决不同协程之间的通信问题。

# 七 问题分析 #

**1 这里使用全局变量加锁同步来解决 goroutine 的通讯，但不完美。**

**2 主线程在等待所有 goroutine 全部完成的时间很难确定，这里设置 10 秒，仅仅是估算。**

**3 如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有 goroutine 处于工作状态，这时也会随主线程的退出而销毁。**

**4 通过全局变量加锁同步来实现通讯，也并不利用多个协程对全局变量的读写操作。**

**5 上面种种分析都在呼唤一个新的通讯机制-channel。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5ncWl1bWluZw_size_16_color_FFFFFF_t_70]: /images/20210724/d464dda0fc374e6c9bba47728f8abe38.png