基本goroutine和通道模式：一个通道多个goroutine

Question

我是新来的，想知道一些很基本的问题，我不能弄清楚。

为了发挥作用（对实际需要的抽象），我需要：

• 用常数迭代
固定的元素初始化字符串片断
• 遍历此切片并为每个元素运行一个goroutine
• 每个goroutine将花费一定的时间来处理元素（随机秒持续时间）
• 作业完成后，我希望goroutine将结果推送到一个通道
• 然后我需要捕获来自这个通道的所有结果（在一个从主goroutine调用的函数中），将它们附加到最后一个切片中，然后，在它完成后
• 打印最终切片的长度并添加一些基本的时间跟踪

毫不奇怪，总的程序时间总是或多或少地等于const max_sec_sleep的值，因为所有的处理都是并行的。

但是呢：

1. 接收部分:

在所有的迭代之后，我应该关闭通道的某个地方吗？但我肯定会在至少一次gouroute完成之前关闭它，以恐慌错误结束（试图发送到关闭的通道）

如果我要插入一个done<-true模式，它会在这里吗？

我没有真正尝试waitgroups，广告我需要一种方法来捕捉所有的'return'值从goroutine，并追加到最后的切片；我没有找到一个合适的方法从一个goroutine返回，除了使用渠道。

我应该在func参数中传递通道还是让它们全局化到程序中？

package main

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

const ITERATIONS = 200

var (
    results   chan string
    initial   []string
    formatted []string
)

func main() {
    defer timeTrack(time.Now(), "program")

    format()  //run format goroutines
    receive() //receive formatted strings

    log.Printf("final slice contains %d/%d elements", len(formatted), len(initial))
}

//gets all results from channel and appends them to formatted slice
func receive() {
    for i := 0; i < ITERATIONS; i++ {
        select {
        case result := <-results:
            formatted = append(formatted, result)
        }
    }
}

//loops over initial slice and runs a goroutine per element
//that does some formatting operation and then pushes result to channel
func format() {
    for i := 0; i < ITERATIONS; i++ {
        go func(i int) {
            //simulate some formatting code that can take a while
            sleep := time.Duration(rand.Intn(10)) * time.Second
            time.Sleep(sleep)
            //append formatted string to result chan
            results <- fmt.Sprintf("%s formatted", initial[i])
        }(i)
    }

}

//initialize chans and inital slice
func init() {
    results = make(chan string, ITERATIONS)
    for i := 0; i < ITERATIONS; i++ {
        initial = append(initial, fmt.Sprintf("string #%d", i))
    }
}

func timeTrack(start time.Time, name string) {
    elapsed := time.Since(start)
    log.Printf("%s took %s", name, elapsed)
}

Answer 1

我找不到一个简单的for（ever）循环来包装select，有两个case（一个从结果通道接收，另一个类似case<-done从函数返回）。会是更好的模式吗？

如果所有写入器完成后通道关闭，则可以使用一个简单的for...range循环：

for result := range ch {
    ... do something with the result ...
}

为了使这个简单的变体工作，通道必须关闭，否则for循环将不会终止。

在所有的迭代之后，我应该关闭通道的某个地方吗？

如果可能的话，是的。

我没有试过服务组...

var wg Sync.WaitGroup
wg.Add(ITERATIONS)

然后你就可以生成所有的Goroutine，让它们运行。当每个运行时，它调用wg.done()来指示完成。

你那时--某个地方；where部分有点棘手-调用wg.wait()等待完成所有编写程序。当所有写入程序都指示完成时，您可以close()通道。

请注意，如果从读取通道的同一个goroutine调用wg.wait()-即将运行for result:=range...循环的goroutine--则会出现一个问题：不能同时从通道读取并等待写入器写入通道。因此，要么在循环结束后调用wg.wait()，这就太晚了；或者在循环开始之前，这太早了。

这使得问题及其解决方案变得清晰：您必须在一个goroutine中读取通道，并在另一个goroutine中执行等待然后关闭。这些goroutines中最多有一个可以是最初进入main函数的主要goroutines。

让等待然后关闭的goroutine成为自己的私人goroutine往往非常简单：

go func() {
    wg.Wait()
    close(results)
}()

例如。

func(args) {
    defer wg.Done()
    ... do the work ...
}

wg.Add(1)
go func(args) // `func` will definitely call `wg.Done`, even if `func` panics

我应该在func参数中传递通道还是让它们全局化到程序中？

在风格上，全局变量总是有点凌乱。这并不意味着你不能使用它们；这取决于你，只要记住所有的权衡。闭包变量没有那么混乱，但请记住对于循环迭代变量要小心：

for i := 0; i < 10; i++ {
    go func() {
        time.Sleep(50 * time.Millisecond)
        fmt.Println(i)  // BEWARE BUG: this prints 10, not 0-9
    }()
}

行为不端。在围棋操场上试试这个；请注意，go vet现在在这里抱怨i的不良使用。