Question

我正在尝试使用频道从一组goroutine中捕获错误，但是频道进入无限循环，开始消耗CPU。

func UnzipFile(f *bytes.Buffer, location string) error {
    zipReader, err := zip.NewReader(bytes.NewReader(f.Bytes()), int64(f.Len()))

    if err != nil {
        return err
    }

    if err := os.MkdirAll(location, os.ModePerm); err != nil {
        return err
    }

    errorChannel := make(chan error)
    errorList := []error{}

    go errorChannelWatch(errorChannel, errorList)

    fileWaitGroup := &sync.WaitGroup{}

    for _, file := range zipReader.File {
        fileWaitGroup.Add(1)
        go writeZipFileToLocal(file, location, errorChannel, fileWaitGroup)
    }

    fileWaitGroup.Wait()

    close(errorChannel)

    log.Println(errorList)

    return nil
}

func errorChannelWatch(ch chan error, list []error) {
    for {
        select {
        case err := <- ch:

            list = append(list, err)
        }
    }
}

func writeZipFileToLocal(file *zip.File, location string, ch chan error, wg *sync.WaitGroup) {
    defer wg.Done()

    zipFilehandle, err := file.Open()

    if err != nil {
        ch <- err
        return
    }

    defer zipFilehandle.Close()

    if file.FileInfo().IsDir() {
        if err := os.MkdirAll(filepath.Join(location, file.Name), os.ModePerm); err != nil {
            ch <- err
        }
        return
    }

    localFileHandle, err := os.OpenFile(filepath.Join(location, file.Name), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())

    if err != nil {
        ch <- err
        return
    }

    defer localFileHandle.Close()

    if _, err := io.Copy(localFileHandle, zipFilehandle); err != nil {
        ch <- err
        return
    }

    ch <- fmt.Errorf("Test error")
}

所以我正在循环一段文件并将它们写入我的磁盘，当出现错误时我会报告回errorChannel以将该错误保存到切片中。

我使用sync.WaitGroup等待所有goroutines，当它们完成时我想打印errorList并检查执行期间是否有任何错误。

即使我在ch <- fmt.Errorf("test")末尾添加writeZipFileToLocal并且频道也会挂断，该列表也始终为空。

我不确定我在这里缺少什么。

Answer 1

<强> 1。对于第一点，无限循环：

引自golang language spec：

封闭频道上的接收操作始终可以继续立即，在任何之后产生元素类型的零值已收到先前发送的值。

所以在这个函数中

func errorChannelWatch(ch chan error, list []error) {
    for {
        select {
        case err := <- ch:

            list = append(list, err)
        }
    }
}

ch关闭后，这变为无限循环，将nil值添加到list。

请改为尝试：

func errorChannelWatch(ch chan error, list []error) {
    for err := range ch {
            list = append(list, err)
    }
}

<强> 2。对于第二点，为什么在错误列表中看不到任何内容：

问题是这个电话：

errorChannel := make(chan error)
errorList := []error{}

go errorChannelWatch(errorChannel, errorList)

您可以errorChannelWatch errorList作为值。因此，函数不会更改切片errorList。更改的是底层数组，只要append调用不需要分配新的数组。

要解决这种情况，可以将切片指针传递给errorChannelWatch，也可以将其重写为对闭包的调用，捕获 errorList。

对于第一个提议的解决方案，请将errorChannelWatch更改为

func errorChannelWatch(ch chan error, list *[]error) {
    for err := range ch {
            *list = append(*list, err)
    }
}

并致电

errorChannel := make(chan error)
errorList := []error{}

go errorChannelWatch(errorChannel, &errorList)

对于第二个提议的解决方案，只需将呼叫更改为

   errorChannel := make(chan error)
   errorList := []error{}

   go func() {
      for err := range errorChannel {
          errorList = append(errorList, err)
      }
   } ()

第3。一个小问题：

有人可能会认为，这里存在同步问题：

fileWaitGroup.Wait()

close(errorChannel)

log.Println(errorList)

如何确认，在关闭调用后，errorList未被修改？有人可能会说，你无法知道goroutine errorChannelWatch仍有多少价值需要处理。

您的同步对我来说似乎是正确的wg.Done() 发送到错误通道后，所有错误值将在fileWaitGroup.Wait()返回时发送。

但如果有人后来为错误添加缓冲，则可能会发生变化渠道或改变代码。

所以我建议至少在评论中解释同步。

去通道无限循环

1 个答案: