有什么作用将ctx.Done()放在select语句中？

欢迎各位小伙伴来到golang学习网，相聚于此都是缘哈哈哈！今天我给大家带来《有什么作用将ctx.Done()放在select语句中？》，这篇文章主要讲到等等知识，如果你对Golang相关的知识非常感兴趣或者正在自学，都可以关注我，我会持续更新相关文章！当然，有什么建议也欢迎在评论留言提出！一起学习！

因此，正如本问题所解释的，select 语句随机选择一个通道操作。我经常看到这样的模式：

func foo(ctx context.Context, someChannel <-chan int) {
    for {
        select {
        case someValue := <-someChannel:
            //do some stuff until the context is done
            expensiveComputation(someValue)
        case <-ctx.Done():
            //context is done - either canceled or time is up for timeout
            return
        }
    }
}

但是如果我们不能保证 select 中的 case 会触发，则 case <-ctx.done() 可能不会立即被选择，而是在几次迭代之后被选择expensecomputation(somevalue)，我们实际上不需要再做了，因为上下文被取消了。也有可能它永远不会被选中，但这种可能性太低了......

go 规范还指出“封闭通道上的接收操作始终可以立即进行，在收到任何先前发送的值后生成元素类型的零值。” 所以也可能的是：

1. 发送者关闭了频道 somechannel
2. 发件人取消了上下文

现在在 select 语句中将有两个操作可以继续、可用，并且将随机选择其中之一，并且在取消上下文后可能会执行一些计算。

那么如何正确处理呢？或者，如果我在这里遗漏了一些东西，那是什么？

正确答案

select语句随机选择一个通道操作

随机选择一个已准备好读取的通道。

有可能，这种情况 <-ctx.done() 不会立即被选择，但是在昂贵的计算(somevalue)的几次迭代之后，我们实际上不需要再做任何事情，因为上下文被取消了

因此，您描述的情况是 somechannel 的写入器继续写入或通道的缓冲区不为空，即使上下文已取消。如果 somechannel 尚未准备好读取，则不会选择它（除非它已关闭，正如您所说，下面将详细介绍）。我想您明白了，我只是想明确表示，永远不会选择未准备好阅读的频道。

expensecomputation(somevalue)

在现实生活中，如果您希望取消快速生效，您可以将上下文传递给 expensecomputation，以便它可以尊重其取消。然后，expensecomputation 可以返回上下文是否在 expensecomputation 期间被取消的指示，以便您可以立即退出 select。这可能看起来像：

if ok := expensivecomputation(ctx, somevalue); !ok {
              // context has been cancelled during `expensivecomputation` 
              return
            }

关闭通道上的接收操作始终可以立即进行

To quote the tour（如果你还没有的话，你应该接受！）

接收者可以通过向接收表达式分配第二个参数来测试通道是否已关闭：after

v, ok := <-ch

如果没有更多值要接收并且通道已关闭，则 ok 为 false。

Keep in mind also that

从零通道接收永远阻塞

因此，如果您想关闭在 select 中读取的通道，则需要结合这两个想法：使用接收中的第二个值来知道通道已关闭，然后将通道设置为 nil 这样就不会'不要继续从中读取零值。

func foo(ctx context.context, somechannel <-chan int) {
    for {
        select {
        case somevalue, ok := <-somechannel:
            if ! ok { 
               somechannel = nil
               // this case will never again  be selected
            } else {
               expensivecomputation(somevalue)
            }
        case <-ctx.done():
            //context is done - either canceled or time is up for timeout
            return
        }
    }
}

就您而言，somechannel 是 foo 的唯一工作来源，但在某些情况下可能涉及多个通道。在您的情况下，当通道关闭时从 foo 返回可能更有意义。

case somevalue, ok := <-somechannel:
            if ! ok { 
               return // end foo, it will receive no more work
            } else {
               expensivecomputation(somevalue)
            }

• 如果您想要一种彻底中断 expensecomputation 的方法，您应该将上下文传递给该函数：

func expensivecomputation(ctx context.context, somevalue int) {
    ...
}

并让此函数检查上下文是否在您认为合适的地方完成

• 有多种方法可以处理上下文取消和关闭通道，其中之一可以是：
  更改生产者，以便在完成生成值和上下文取消时关闭通道

以下是如何执行此操作的示例：

func producer(ctx context.context, count int, values chan<- int) {
    defer close(values)

    for i := 0; i < count; i++ {
        select {
        case values <- i:
            // keep iterating the loop
        case <-ctx.done():
            // exit loop
            break
        }
    }
}

func foo(ctx context.context, values <-chan int) {
    for i := range values {
        expensivecomputation(ctx, i)
    }
}

func expensivecomputation(ctx context.context, i int) {
    select {
    case <-ctx.done():
        fmt.printf("expensivecomputation %d: cancelled via context\n", i)
    case <-time.after(time.second):
        fmt.printf("expensivecomputation %d: completed\n", i)
    }
}

func main() {
    ctx := context.background()

    ctx, cancel := context.withtimeout(ctx, 3500*time.millisecond)
    defer cancel()

    values := make(chan int, 0)
    go producer(ctx, 10, values)

    foo(ctx, values)
}

https://go.dev/play/p/aEm5xTus5CW

只是为了说明始终首先检查取消的另一种方法，对代码的修改较少：您可以在选择指令之前添加单独的检查：

func foo(ctx context.context, somechannel <-chan int) {
    for {
        // explicitly check for context cancellation first:
        select {
        case <-ctx.done():
            // context is done: return now
            return
        default:
            // keep running
        }

        select {
        case somevalue := <-somechannel:
            expensivecomputation(somevalue)
        case <-ctx.done():
            return
        }
    }
}

如果您还想检查 somechannel 是否已关闭，则必须添加对通道状态的检查，如 @timohahaa wrote in his answer ：

func foo(ctx context.Context, someChannel <-chan int) {
    for {
        select {
        case <-ctx.Done():
            return
        default:
        }

        select {
        case someValue, ok := <-someChannel:
            if !ok {
                // channel is closed, stop now
                return
            }
            expensiveComputation(someValue)
        case <-ctx.Done():
            return
        }
    }
}

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~