Question

我试图理解非缓冲通道，因此我编写了一个小应用程序，该应用程序迭代用户输入数组，执行一些工作，将信息放置在非缓冲通道上，然后读取它。但是，我无法从频道中读取内容。这是我的代码

toProcess := os.Args[1:]

var wg sync.WaitGroup
results := make(chan string)
errs := make(chan error)

for _, t := range toProcess {
    wg.Add(1)
    go Worker(t, "text", results, errs, &wg)
}


go func() {
    for err := range errs {
        if err != nil {
            fmt.Println(err)
        }
    }
}()


go func() {
    for res := range results {
        fmt.Println(res)
    }
}()

我对非缓冲通道不了解什么？我以为我应该在上面放些信息，然后再从中读取常规信息。

编辑：使用两个goroutines可以解决问题，但是当出现错误时，它仍然为我提供以下信息：

open /Users/roosingh/go/src/github.com/nonbuff/files/22.txt: no such file or directory
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [semacquire]:
sync.runtime_Semacquire(0xc42001416c)
    /usr/local/Cellar/go/1.10.2/libexec/src/runtime/sema.go:56 +0x39
sync.(*WaitGroup).Wait(0xc420014160)
    /usr/local/Cellar/go/1.10.2/libexec/src/sync/waitgroup.go:129 +0x72
main.main()
    /Users/roosingh/go/src/github.com/nonbuff/main.go:39 +0x207

goroutine 6 [chan receive]:
main.main.func1(0xc4200780c0)
    /Users/roosingh/go/src/github.com/nonbuff/main.go:25 +0x41
created by main.main
    /Users/roosingh/go/src/github.com/nonbuff/main.go:24 +0x1d4

goroutine 7 [chan receive]:
main.main.func2(0xc420078060)
    /Users/roosingh/go/src/github.com/nonbuff/main.go:34 +0xb2
created by main.main
    /Users/roosingh/go/src/github.com/nonbuff/main.go:33 +0x1f6

因此它可以打印出错误消息。我的工作程序代码如下；

func Worker(fn string, text string, results chan string, errs chan error, wg *sync.WaitGroup) {
    file, err := os.Open(fn)
    if err != nil {
        errs <- err
        return
    }
    defer func() {
        file.Close()
        wg.Done()
    }()

    reader := bufio.NewReader(file)


    for {
        var buffer bytes.Buffer

        var l []byte
        var isPrefix bool
        for {
            l, isPrefix, err = reader.ReadLine()
            buffer.Write(l)

            if !isPrefix {
                break
            }

            if err != nil {
                errs <- err
                return

            }
        }

        if err == io.EOF {
            return
        }

        line := buffer.String()

        results <- fmt. Sprintf("%s, %s", line, text)

    }

    if err != io.EOF {
        errs <- err
        return
    }

    return
}

Answer 1

对于无缓冲通道，您似乎理解了这个概念，这意味着它用于在goroutine之间传递消息，但不能容纳任何消息。因此，在无缓冲通道上的写操作将被阻塞，直到另一个goroutine从该通道读取为止，从一个通道的读取将被阻塞，直到另一个goroutine向该通道写入为止。

在您的情况下，您似乎想在同一goroutine中同时读取2个通道。由于通道的工作方式，因此您无法在非封闭通道上进行范围调整，而无法在另一个通道上的同一goroutine范围内进一步进行调整。除非第一个通道关闭，否则您将不会到达第二个范围。

但是，这并不意味着不可能！这就是select语句的来源。

select语句允许您有选择地从多个通道读取，这意味着它将读取第一个具有可读取内容的通道。

请记住，您可以将for与select结合使用，并以这种方式重写例程：

go func() {
    for {
        select {
            case err := <- errs: // you got an error
                fmt.Println(err) 
            case res := <- results: // you got a result
                fmt.Println(res)
        }
    }
}()

此外，您在这里不需要等待组，因为您知道要启动的工人数量，因此只需计算出多少错误和结果，并在达到工人数量时停止。

示例：

go func() {
    var i int
    for {
        select {
            case err := <- errs: // you got an error
                fmt.Println(err)
                i++
            case res := <- results: // you got a result
                fmt.Println(res)
                i++
        }
        // all our workers are done
        if i == len(toProcess) {
            return 
        }
    }
}()

从非缓冲通道读取

1 个答案: