无限goroutine，直到收到所需的响应

我尝试在无限循环中启动goroutines，直到得到我要查找的响应，但是如果我更改I:=0的

，则无法访问
选择
；i<10；i++{}
到{}
的
。解决这个问题的模式是什么

package main

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

func myFunc() float64 {

    c := make(chan float64)

    for i := 0; i < 10; i++ {
        go func() {

            var value float64
            value = someOp()

            if value > .9 {
                c <- value
            }

        }()
    }

    // unreachable code the if the for loop above is infinite
    for {
        select {
        case x := <-c:
            return x
        default:
        }
    }

}

func someOp() float64 {
    rand.Seed(time.Now().UnixNano())
    return rand.Float64()
}

func main() {
    fmt.Println(myFunc())
}

主程序包
进口(
“fmt”
“数学/兰德”
“时间”
)
func myFunc（）浮点64{
c:=制造（64）
对于i:=0；i<10；i++{
go func（）{
var值浮动64
value=someOp（）
如果值>0.9{
c启动无限数量的goroutine通常不是一个好主意。更好的方法是启动固定数量的goroutine循环寻找答案。找到答案后从这些goroutine返回

func myFunc() float64 {
    c := make(chan float64, 1) // Size 1 prevents race between main goroutine and workers

    done := make(chan struct{})
    defer close(done)

    // Start a fixed number of goroutines
    for i := 0; i < 10; i++ {
        go func() {
            for {
                select {
                case <-done:
                    // myfunc exited with result, return from this goroutine
                    return
                default:
                    var value float64
                    value = someOp()
                    if value > .9 {
                        select {
                        case c <- value:
                            // This is first goroutine to send a value
                        default:
                            // Another goroutine sent a value
                        }
                        return
                    }

                }
            }
        }()
    }
    return <-c
}

func myFunc（）浮点64{
c:=make（64，1）//尺寸1防止主goroutine和worker之间的竞争
完成：=make（chan结构{}）
延迟关闭（完成）
//启动固定数量的goroutine
对于i:=0；i<10；i++{
go func（）{
为了{
挑选{
案例9{
挑选{
案例c启动无限数量的goroutine通常不是一个好主意。更好的方法是启动固定数量的goroutine，循环寻找答案。找到答案后从这些goroutine返回

func myFunc() float64 {
    c := make(chan float64, 1) // Size 1 prevents race between main goroutine and workers

    done := make(chan struct{})
    defer close(done)

    // Start a fixed number of goroutines
    for i := 0; i < 10; i++ {
        go func() {
            for {
                select {
                case <-done:
                    // myfunc exited with result, return from this goroutine
                    return
                default:
                    var value float64
                    value = someOp()
                    if value > .9 {
                        select {
                        case c <- value:
                            // This is first goroutine to send a value
                        default:
                            // Another goroutine sent a value
                        }
                        return
                    }

                }
            }
        }()
    }
    return <-c
}

func myFunc（）浮点64{
c:=make（64，1）//尺寸1防止主goroutine和worker之间的竞争
完成：=make（chan结构{}）
延迟关闭（完成）
//启动固定数量的goroutine
对于i:=0；i<10；i++{
go func（）{
为了{
挑选{
案例9{
挑选{
案例c开始无限数量的goroutine通常不是一个好主意。更好的方法是开始一个固定数量的goroutine来搜索解决方案。我实际上并不想要无限数量的goroutine，而是继续添加赛车手，直到其中一个获胜，然后丢弃所有输家。如果第一个for循环是无限的，则嗯，程序控制根本不会出来，你将生成无限多的围棋程序。也许我应该简单地尝试N名选手，如果比赛结束时仍然没有赢家，那么就进行另一场比赛（开始另一个循环）。基本上，我正在尝试用go例程和通道重构递归函数。使用quit在通道上发送值以退出启动无限数量的goroutine通常不是一个好主意。更好的方法是启动固定数量的goroutine来搜索解决方案。我实际上不想要无限数量的goroutine如果第一个for循环是无限的，那么程序控制根本不会从中出来，你将生成无限多的go例程。也许我应该试试N个赛车手，如果在比赛结束时仍然没有赢家，那么就有第二个er比赛（开始另一个循环）。基本上，我正在尝试用go例程和通道重构递归函数。使用quit将通道上的值发送到quit。不幸的是，就像我问题中发布的代码一样，这并不能解决递归问题。@malablaster我回答了提出的问题。更新问题以解释您的要求，包括重新定义的示例反映了这些要求。问题中没有任何内容表明需要递归。注释中提到了递归。我没有看到您的解决方案比我的原始代码增加了什么价值。您能详细说明吗？@malablaster增加的价值是此解决方案实际工作……您必须详细说明它对您的函数是递归的。我看不出这会有什么改变。@malablaster你提到了递归，但它的意义还不清楚。在回答你对ThunderCat的问题时，它不会运行10次迭代，它会运行10次gouroutines，直到有人吐出一个值，然后它们都退出。注意，内部for循环是一个无限循环，但完成后将返回。请参见我将其变得更难并打印的示例。不幸的是，与我问题中发布的代码一样，这并不能解决递归问题。@malablaster我回答了提出的问题。请更新问题以解释您的需求，包括反映这些需求的示例。问题中没有任何内容表明声明需要递归。注释中提到了递归。我没有看到您的解决方案在我的原始代码上增加了什么价值。您能详细说明吗？@malablaster增加的价值是，这个解决方案实际上可以工作……您必须详细说明函数递归的区别。我看不出会有什么变化malablaster你提到了递归，但它的意义还不清楚。在回答你对ThunderCat的问题时，它没有运行10次迭代，它运行10次gouroutines，无限次地运行，直到有人吐出一个值，然后它们都退出。注意，内部for循环是一个无限循环，但在完成后将返回。看到我在它不难印刷。