如何根据该 goroutine 的返回值停止 goroutine

Question

像这里一样，我创建了一个 go playground 示例：sGgxEh40ev，但无法让它工作。

quit := make(chan bool)
res := make(chan int)

go func() {
    idx := 0
    for {
        select {
        case <-quit:
            fmt.Println("Detected quit signal!")
            return
        default:
            fmt.Println("goroutine is doing stuff..")
            res <- idx
            idx++
        }
    }

}()

for r := range res {
    if r == 6 {
        quit <- true
    }
    fmt.Println("I received: ", r)
}

输出：

goroutine is doing stuff..
goroutine is doing stuff..
I received:  0
I received:  1
goroutine is doing stuff..
goroutine is doing stuff..
I received:  2
I received:  3
goroutine is doing stuff..
goroutine is doing stuff..
I received:  4
I received:  5
goroutine is doing stuff..
goroutine is doing stuff..
fatal error: all goroutines are asleep - deadlock!

这可能吗？我哪里错了

Answer 1

由于@icza 的答案非常干净，@Ravi 采用同步方式。

但是因为我不想花那么多精力去重构代码，也不想走同步的方式，所以最终还是去了defer panic recover流控，如下：

func test(ch chan<- int, data []byte) {
    defer func() {
        recover()
    }()
    defer close(ch)

    // do your logic as normal ...
    // send back your res as normal `ch <- res`
}

// Then in the caller goroutine

ch := make(chan int)
data := []byte{1, 2, 3}
go test(ch, data)

for res := range ch {
    // When you want to terminate the test goroutine:
    //     deliberately close the channel
    //
    // `go -race` will report potential race condition, but it is fine
    //
    // then test goroutine will be panic due to try sending on the closed channel,
    //     then recover, then quit, perfect :) 
    close(ch)
    break
}

这种方法有什么潜在风险吗？

Answer 2

问题是在 goroutine 中你使用 select 来检查它是否应该中止，但你使用 default 分支来完成工作。

如果没有通信（列在case 分支中）可以进行，则执行default 分支。因此，在每次迭代中检查quit 通道，但如果无法从其接收（无需退出），则执行default 分支，无条件尝试在@987654330 上发送值@。现在如果主 goroutine 还没有准备好接收它，这将是一个死锁。这正是发送值为6 时发生的情况，因为那时主goroutine 会尝试在quit 上发送值，但是如果worker goroutine 在default 分支中尝试在res 上发送值，然后两个 goroutine 都尝试发送一个值，但没有一个尝试接收！两个通道都没有缓冲，所以这是一个死锁。

在工作 goroutine 中，您必须使用正确的 case 分支在 res 上发送值，而不是在 default 分支中：

select {
case <-quit:
    fmt.Println("Detected quit signal!")
    return
case res <- idx:
    fmt.Println("goroutine is doing stuff..")
    idx++
}

在主 goroutine 中，你必须跳出 @9​​87654339@ 循环，这样主 goroutine 才能结束，程序也可以结束：

if r == 6 {
    quit <- true
    break
}

这次输出（在Go Playground上试试）：

goroutine is doing stuff..
I received:  0
I received:  1
goroutine is doing stuff..
goroutine is doing stuff..
I received:  2
I received:  3
goroutine is doing stuff..
goroutine is doing stuff..
I received:  4
I received:  5
goroutine is doing stuff..
goroutine is doing stuff..

Answer 3

根本问题是，如果消费者（在您的情况下为主要）决定退出阅读（在您的代码中这是可选的），则生产者必须始终在发送值之间检查。发生的事情甚至在发送（和接收）退出值之前，生产者继续发送res 上的下一个值，消费者永远无法读取 - 消费者实际上正在尝试在退出频道，期待生产者阅读。添加了可以帮助您理解的调试语句：https://play.golang.org/p/mP_4VYrkZZ，-生产者试图在 res 和阻塞时发送 7，然后消费者试图在退出和阻塞时发送值。死锁！

一种可能的解决方案如下（使用 Waitgroup 是可选的，仅当您需要在返回之前从生产者端干净退出时才需要）：

package main

import (
    "fmt"
    "sync"
)

func main() {
    //WaitGroup is needed only if need a clean exit for producer
    //that is the producer should have exited before consumer (main)
    //exits - the code works even without the WaitGroup
    var wg sync.WaitGroup
    quit := make(chan bool)
    res := make(chan int)

    go func() {
        idx := 0
        for {

            fmt.Println("goroutine is doing stuff..", idx)
            res <- idx
            idx++
            if <-quit {
                fmt.Println("Producer quitting..")
                wg.Done()
                return
            }

            //select {
            //case <-quit:
            //fmt.Println("Detected quit signal!")
            //time.Sleep(1000 * time.Millisecond)
            //  return
            //default:
            //fmt.Println("goroutine is doing stuff..", idx)
            //res <- idx
            //idx++
            //}
        }


    }()
    wg.Add(1)
    for r := range res {
        if r == 6 {
            fmt.Println("Consumer exit condition met: ", r)
            quit <- true
            break
        }
        quit <- false
        fmt.Println("I received: ", r)
    }
    wg.Wait()

}

输出：

goroutine is doing stuff.. 0
I received:  0
goroutine is doing stuff.. 1
I received:  1
goroutine is doing stuff.. 2
I received:  2
goroutine is doing stuff.. 3
I received:  3
goroutine is doing stuff.. 4
I received:  4
goroutine is doing stuff.. 5
I received:  5
goroutine is doing stuff.. 6
Consumer exit condition met:  6
Producer quitting..

在操场上：https://play.golang.org/p/N8WSPvnqqM