避免重复案例的嵌套选择的模式

Question

我正在阅读 O'Reilly 的 Go 并发书，并找到了以下代码示例：

doWork := func(
    done <-chan interface{},
    pulseInterval time.Duration,
) (<-chan interface{}, <-chan time.Time) {
    heartbeat := make(chan interface{})
    results := make(chan time.Time)
    go func() {
        defer close(heartbeat)
        defer close(results)
        pulse := time.Tick(pulseInterval)
        workGen := time.Tick(2 * pulseInterval) // this just creates workload
        sendPulse := func() {
            select {
            case heartbeat <- struct{}{}:
            default:
            }
        }
        sendResult := func(r time.Time) {
            for {
                select {
                case <-done:
                    return
                case <-pulse:
                    sendPulse()
                case results <- r:
                    return
                }
            }
        }
        for {
            select {
            case <-done:
                return
            case <-pulse:
                sendPulse()
            case r := <-workGen:
                sendResult(r)
            }
        }
    }()
    return heartbeat, results
}

两个 select 语句被用于一个简单的心跳似乎很奇怪。然后我明白了这背后的原因是 sendResults 不应该阻止尝试将结果发送到results 频道。如果没有人从该通道接收，它将有效地阻塞 goroutine 并停止发送心跳。

然后我想……他们为什么不这样编码呢？

doWork := func(
    done <-chan interface{},
    pulseInterval time.Duration,
) (<-chan interface{}, <-chan time.Time) {
    heartbeat := make(chan interface{})
    results := make(chan time.Time)
    go func() {
        defer close(heartbeat)
        defer close(results)
        pulse := time.Tick(pulseInterval)
        workGen := time.Tick(2 * pulseInterval) // this just creates workload
        sendPulse := func() {
            select {
            case heartbeat <- struct{}{}:
            default:
            }
        }
        for {
            select {
            case <-done:
                return
            case <-pulse:
                sendPulse()
            case results <- <- workgen:
                fmt.Println("Send result")
            }
        }
    }()
    return heartbeat, results
}

并意识到这是因为如果 workgen 有一个可用的项目并且我阅读了它但没有人从结果中读取，那么 workgen 项目将会丢失。

问题

是否有任何其他模式可以避免这些必须重复所有情况才能不遗漏值的嵌套选择？

想法

如果一个 select 语句首先验证结果通道正在等待接收一个值而不是先执行右手表达式，那么难道所有这些问题都不会得到解决吗？

换句话说，如果我有这个results <- <- workgen，如果选择说“嘿，没有人从结果中读取，我们不要尝试评估

我认为一个案例应该首先尝试评估表达式中的通道是否准备好接收或发送数据，然后执行表达式。

Answer 1

在选择中为workgen 和results 使用临时变量。根据当前状态将这些变量设置为nil 或原始值。

将变量设置为 nil 会禁用 select 的分支，因为 nil 通道上的通道操作会永远阻塞。

    workGenT := workGen
    var resultsT chan time.Time
    var result time.Time
    for {
        select {
        case <-done:
            return
        case <-pulse:
            sendPulse()
        case result = <-workgenT:
            workgenT = nil
            resultsT = results
        case resultsT <- result:
            resultsT = nil
            workgenT = workgen
        }
    }

因为workgenT和resultsT只有一个是非nil，所以上面的代码有两种状态：程序要么等待接收结果，要么等待发送结果。

Answer 2

另一个简单相似的模式。

func hBeatTicker(ctx context.Context, ch chan<- struct{}, t time.Duration) {
    tick := time.NewTicker(t)
    for {
        select {
        case <-ctx.Done():
            close(ch)
            tick.Stop()
            return
        case <-tick.C:
            ch <- struct{}{}
        }
    }
}

func workGen(ctx context.Context, ch chan<- time.Time, t time.Duration) {
    tick := time.NewTicker(2 * t)
    for {
        select {
        case <-ctx.Done():
            close(ch)
            tick.Stop()
            return
        case ch <- <-tick.C:
        }
    }
}

func do(ctx context.Context, d time.Duration) (<-chan struct{}, <-chan time.Time) {
    heartbeat, results := make(chan struct{}), make(chan time.Time)

    go workGen(ctx, results, d)
    go hBeatTicker(ctx, heartbeat, d)

    return heartbeat, results
}