我有一个简单的并发用例，它让我疯狂，我无法找到一个优雅的解决方案。任何帮助将不胜感激。
我想编写一个方法fetchAll，它可以并行地从远程服务器查询未指定数量的资源。如果任何提取失败，我想立即返回第一个错误。
我最初的，天真的实现，泄漏了goroutines：
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func fetchAll() error {
wg := sync.WaitGroup{}
errs := make(chan error)
leaks := make(map[int]struct{})
defer fmt.Println("these goroutines leaked:", leaks)
// run all the http requests in parallel
for i := 0; i < 4; i++ {
leaks[i] = struct{}{}
wg.Add(1)
go func(i int) {
defer wg.Done()
defer delete(leaks, i)
// pretend this does an http request and returns an error
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
errs <- fmt.Errorf("goroutine %d's error returned", i)
}(i)
}
// wait until all the fetches are done and close the error
// channel so the loop below terminates
go func() {
wg.Wait()
close(errs)
}()
// return the first error
for err := range errs {
if err != nil {
return err
}
}
return nil
}
func main() {
fmt.Println(fetchAll())
}
游乐场：https://play.golang.org/p/Be93J514R5
我从阅读https://blog.golang.org/pipelines知道我可以创建一个信号通道来清理其他线程。或者，我可以使用context来完成它。但似乎这样一个简单的用例应该有一个我想要的更简单的解决方案。
答案 0 :(得分：8)
除了你的一个goroutine外，其他所有人都被泄露了，因为他们还在等待发送到errs频道 - 你永远不会完成清空它的范围。你也正在泄漏goroutine，他的工作就是关闭errs通道，因为waitgroup从未完成。
（另外，正如Andy指出的那样，从地图中删除不是线程安全的，因此需要保护互斥锁。）
但是，我认为这里甚至不需要地图，互斥体，等待组，上下文等。我将重写整个事情只是使用基本的通道操作，如下所示：
package main
import (
"fmt"
"math/rand"
"time"
)
func fetchAll() error {
var N = 4
quit := make(chan bool)
errc := make(chan error)
done := make(chan error)
for i := 0; i < N; i++ {
go func(i int) {
// dummy fetch
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
err := error(nil)
if rand.Intn(2) == 0 {
err = fmt.Errorf("goroutine %d's error returned", i)
}
ch := done // we'll send to done if nil error and to errc otherwise
if err != nil {
ch = errc
}
select {
case ch <- err:
return
case <-quit:
return
}
}(i)
}
count := 0
for {
select {
case err := <-errc:
close(quit)
return err
case <-done:
count++
if count == N {
return nil // got all N signals, so there was no error
}
}
}
}
func main() {
rand.Seed(time.Now().UnixNano())
fmt.Println(fetchAll())
}
游乐场链接：https://play.golang.org/p/mxGhSYYkOb
编辑：确实有一个愚蠢的错误，谢谢你指出来。我修改了上面的代码（我认为......）。我还添加了一些随机性来添加Realism™。另外，我想强调的是，确实有多种方法可以解决这个问题，而我的解决方案只有一种方法。归根结底，它归结为个人品味，但总的来说，您希望努力实现“惯用”代码 - 并且采用自然且易于理解的风格。
答案 1 :(得分：4)
使用Error Group使其更加简单。这将自动等待所有提供的Go例程成功完成，或者在任何一个例程返回错误（在这种情况下该错误是返回给调用者的一个气泡）的情况下，取消所有剩余的Go例程。
package main
import (
"context"
"fmt"
"math/rand"
"time"
"golang.org/x/sync/errgroup"
)
func fetchAll(ctx context.Context) error {
errs, ctx := errgroup.WithContext(ctx)
// run all the http requests in parallel
for i := 0; i < 4; i++ {
errs.Go(func() error {
// pretend this does an http request and returns an error
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
return fmt.Errorf("goroutine %d's error returned", i)
})
}
// Wait for completion and return the first error (if any)
return errs.Wait()
}
func main() {
fmt.Println(fetchAll(context.Background()))
}
答案 2 :(得分：0)
只要每个goroutine完成，你就不会泄漏任何东西。您应该创建缓冲的错误通道，缓冲区大小等于goroutines的数量，以便通道上的发送操作不会阻塞。无论是成功还是失败，每个goroutine都应该在通道完成时发送一些东西。然后底部的循环可以迭代goroutines的数量，如果它得到非零错误则返回。您不需要WaitGroup或其他关闭频道的goroutine。
我认为goroutines泄漏的原因是当你收到第一个错误时你会返回，所以其中一些仍在运行。
顺便说一句，地图不是安全的。如果您在goroutines之间共享地图并且其中一些正在对地图进行更改，则需要使用互斥锁保护它。
答案 3 :(得分：0)
这是errgroup建议的使用joth的更完整的示例。它显示处理成功的数据，并且将在第一个错误时退出。
https://play.golang.org/p/rU1v-Mp2ijo
package main
import (
"context"
"fmt"
"golang.org/x/sync/errgroup"
"math/rand"
"time"
)
func fetchAll() error {
g, ctx := errgroup.WithContext(context.Background())
results := make(chan int)
for i := 0; i < 4; i++ {
current := i
g.Go(func() error {
// Simulate delay with random errors.
time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
if rand.Intn(2) == 0 {
return fmt.Errorf("goroutine %d's error returned", current)
}
// Pass processed data to channel, or receive a context completion.
select {
case results <- current:
return nil
// Close out if another error occurs.
case <-ctx.Done():
return ctx.Err()
}
})
}
// Elegant way to close out the channel when the first error occurs or
// when processing is successful.
go func() {
g.Wait()
close(results)
}()
for result := range results {
fmt.Println("processed", result)
}
// Wait for all fetches to complete.
return g.Wait()
}
func main() {
fmt.Println(fetchAll())
}
答案 4 :(得分：-1)
此答案包括将响应返回到 doneData -
package main
import (
"fmt"
"math/rand"
"os"
"strconv"
)
var doneData []string // responses
func fetchAll(n int, doneCh chan bool, errCh chan error) {
partialDoneCh := make(chan string)
for i := 0; i < n; i++ {
go func(i int) {
if r := rand.Intn(100); r != 0 && r%10 == 0 {
// simulate an error
errCh <- fmt.Errorf("e33or for reqno=" + strconv.Itoa(r))
} else {
partialDoneCh <- strconv.Itoa(i)
}
}(i)
}
// mutation of doneData
for d := range partialDoneCh {
doneData = append(doneData, d)
if len(doneData) == n {
close(partialDoneCh)
doneCh <- true
}
}
}
func main() {
// rand.Seed(1)
var n int
var e error
if len(os.Args) > 1 {
if n, e = strconv.Atoi(os.Args[1]); e != nil {
panic(e)
}
} else {
n = 5
}
doneCh := make(chan bool)
errCh := make(chan error)
go fetchAll(n, doneCh, errCh)
fmt.Println("main: end")
select {
case <-doneCh:
fmt.Println("success:", doneData)
case e := <-errCh:
fmt.Println("failure:", e, doneData)
}
}
使用 go run filename.go 50 执行，其中 N=50，即并行量