示例：控制 Goroutines 同时执行

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《示例：控制 Goroutines 同时执行》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

我正在通过 udemy 课程学习基础 go。在goroutines部分，有一个节流的例子，这让我对等待组的工作原理有了更深的理解。

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "time"
)

func main() {
    c1 := make(chan int)
    c2 := make(chan int)

    go populate(c1)

    go fanOutIn(c1, c2)

    for v := range c2 {
        fmt.Println(v)
    }

    fmt.Println("about to exit")
}

func populate(c chan int) {
    for i := 0; i < 100; i++ {
        c <- i
    }
    close(c)
}

func fanOutIn(c1, c2 chan int) {
    var wg sync.WaitGroup
    const goroutines = 10
    wg.Add(goroutines) 
    for i := 0; i < goroutines; i++ {
        go func() {
            for v := range c1 {
                func(v2 int) {
                    c2 <- timeConsumingWork(v2)
                }(v)
            }
            wg.Done()
        }()
    }
    wg.Wait()
    close(c2)
}

func timeConsumingWork(n int) int {
    time.Sleep(time.Microsecond * time.Duration(rand.Intn(500)))
    return n + rand.Intn(1000)
}

与我的理解不一致的部分是在函数 fanoutin 中，我们在其中设置了 waitgroup 和 add(10)。

为什么我会打印出 100 个值？只能将单个值 (i := 0) 放入 c1，并且该值永远不会从通道中显式删除。然后代码命中wg.done()，等待组队列减少到9个，依此类推。

根据我目前的理解，我希望看到 0 + rand.intn(1000) 的 10 个值。

解决方案

分离出来的函数如下（包括前面的 go 和调用它的括号）：

go func() {
    for v := range c1 {
        func(v2 int) {
            c2 <- timeconsumingwork(v2)
        }(v)
    }
    wg.done()
}()

这段代码有点奇怪。让我们进一步缩小它，丢弃 wg.done 并仅保留 for 循环本身：

for v := range c1 {
    func(v2 int) {
        c2 <- timeconsumingwork(v2)
    }(v)
}

有一个内部未命名函数在这里几乎没有用；我们可以在不改变程序行为的情况下丢弃它，得到：

for v := range c1 {
    c2 <- timeconsumingwork(v)
}

这最终是一个简单的循环。现在的一个关键问题是：您期望此循环进行多少次迭代？注意：它不一定是任何常量数字。也许更好的表达问题的方式是：这个循环什么时候结束？

for 循环读取通道。当从通道读取数据表明不再有数据时，即通道已关闭并且其队列为空时，这种循环就会结束。 （参见 the Go specification section on for loops。）

因此，这个最内循环 for v := range c1 不会终止，直到通道 c1 关闭并且其队列中没有更多数据为止。该频道是通过以下内容创建的：

c1 := make(chan int)

所以它没有队列，所以我们甚至不需要考虑这一点：它在 close(c1) 关闭它之后终止。 您现在应该寻找关闭 c1 的 close。

我们的终点在哪里？

这是关闭c1的地方：

func populate(c chan int) {
    for i := 0; i < 100; i++ {
        c <- i
    }
    close(c)
}

我们用 c1 作为参数来调用它，所以它的最终 close(c) 关闭 c1。现在你可以问：我们什么时候到达这个 close 调用？答案很明显：在循环中 i >= 100 之后，即，在我们将 100 个值（分别为 0 到 99）发送到通道之后c1。

fanoutin 的作用是派生出 10 个 goroutine。这 10 个 goroutine 中的每一个都运行我上面引用的第一个匿名函数。该匿名函数有一个运行不确定次数的循环，重复执行直到通道 c1 关闭。循环中的每次循环都会获取通道的值，因此最初，如果十个 goroutine 在有任何可用值之前都设法启动，则所有十个 goroutine 将等待值。

当生产者函数将一个值放入通道时，十个等待的 goroutine 中的一个将获取该值并开始使用它。如果该 goroutine 需要很长时间才能返回到其自己的 for 循环的顶部，则另一个 goroutine 将采用下一个生成的值。因此，这里发生的情况是，最多十个生成值通过通道传播到最多十个 goroutine。¹ 这些（最多十个）goroutines 中的每一个都会花费一些不小的数量time 使用其值，然后将最终产品值发送到通道 c2 并返回到其自己的无限 for 循环的顶部。

只有当生产者关闭其通道 c（这里是我们的 c1）时，十个 goroutine 才会看到一个封闭通道空队列，允许它们退出 for 循环。当他们退出 for 循环时，每个循环都会调用 wg.done() （每个一次）并终止。

因此，一旦 close(c1) 发生（通过 populate 中的 close(c)），最终所有这些匿名 goroutine 将调用 wg.done()。此时，fanoutin 中的 wg.wait() 将返回。这将调用 close(c2) 并从 fanoutin 返回，同时终止该 goroutine。

同时，在main中，我们使用for v := range c2从通道c2读取。当十个 goroutine 中的任何一个将值写入 c2 时，此 for 循环将运行。仅当 c2 本身关闭时才会退出（其队列也必须为空，但 c2 的队列长度为零）。因此，main 不会继续过去 for 循环，直到 c2 关闭为止，这在 wg.wait() 返回之前不会发生，这在 wg.done() 调用发生之前不会发生，这不能发生直到通道 c1 关闭为止发生。

这意味着 main 无法通过其自己的 for 循环，直到 populate 调用 close(c)，并且只有在恰好生成 100 个值之后才会发生这种情况。

¹正如 in comments below 中所讨论的，这里的短语 up to 可能很重要：我们真的不知道有多少 goroutine 会真正消耗值。很大程度上取决于每个 goroutine 做了多少工作、工作类型以及 go 运行时有多少个可用的 cpu。

终于介绍完啦！小伙伴们，这篇关于《示例：控制 Goroutines 同时执行》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！