彻底弄懂Golang中资源竞争问题

写在前面

咱们都知道，在并发编程中，线程安全是十分重要的。接下来咱们就假定一个场景，复现一下线程不安全的情况，再聊聊如安在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语言中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语言中敞开一个协程的关键字即可。

履行成果便是，控制台啥都没输出，这是由于主协程和子协程之间的履行关系，下面咱们画图了解

从上图中咱们能够发现，主协程履行的时间短（表现在比较短），子协程履行时间比较长（表现在比较长） 咱们一定要记住，子协程是相对于当前的主协程来说的，假如主协程不存在了，那就没有子协程了

所以上面代码啥都没输出便是由于，主协程已经履行完了，可是子协程还没做完，那子协程都没做完，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)
    }
}

当并发数比较小的时分，这个问题或许不会出现，一旦并发数变大，问题就立马出现了

图中的履行成果是并发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)
    }
}

履行成果有0或许是数据类型存不下了导致的，这个咱们不必关心

这样咱们就处理了资源竞争的问题了。但其实还有一个问题，便是咱们在主协程中还是有必要手动等待，这要十分欠好，那假如子协程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函数）