假设一个 channel 有 10 个发送者和一个接收者。发送端函数需要一些时间来返回值。接收者只希望从 channel 中得到一个值(第一个接收到的值)，其他 9 个值不用。接收方不需要等待剩下的 9 个值。这就是为什么我没有使用 sync.WaitGroup .

我使用了一个缓冲 channel ，所以当接收方只接收第一个数据时，缓冲 channel 中将有 9 个数据。我的问题是:

1. 在没有接收方的情况下，是否可以保留数据打开的缓冲 channel ？下面的示例代码是一个简化的代码，但是如果程序是守护进程，它最终会被垃圾回收吗？

2. 有没有更好的方法来处理这种情况？我尝试使用取消 channel 但失败了。我不确定 context适合这种情况。

示例代码:

package main

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

func main() {
    rand.Seed(time.Now().UnixNano())

    i, err := getRandomInt()
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(i)
    }

    fmt.Println("Waiting goroutines to be finished...")
    time.Sleep(2 * time.Second)
}

func getRandomInt() (int, error) {
    ch := make(chan int, 10)

    // 10 senders
    for i := 0; i < 10; i++ {
        go func(i int) {
            defer fmt.Printf("Goroutine #%d finished\n", i)
            fmt.Printf("Goroutine #%d started\n", i)

            data := heavyJob()
            ch <- data
            fmt.Printf("Goroutine #%d sent data %d to ch\n", i, data)
            return
        }(i)
    }

    // 1 receiver
    timeout := time.After(2000 * time.Millisecond)
    for {
        select {
        case value := <-ch:
            // uses only the value received first, the rest are discarded
            return value, nil
        case <-timeout:
            return -1, errors.New("Timeout")
        }
    }
}

// takes 1900~2900ms to finish
func heavyJob() int {
    r := rand.Intn(1000)
    time.Sleep(time.Duration(r+1900) * time.Millisecond)
    return r
}

Run on playground

最佳答案

回答主要问题:

1. 离开 channel 没问题，会被垃圾回收。
2. 这似乎是基于个人观点，但对我来说，如果你创建一个有 10 个空格的缓冲 channel 的唯一原因是发送者 goroutines 可以退出；感觉它会从重新设计中受益。还有其他(也许更好)的方法可以确保发送者 goroutines 可以关闭。

本质上，您是在工作人员数量和缓冲 channel 的大小之间创建一个隐式耦合。更改这两个数字中的一个，就会出现死锁/中断! (附带说明一下，缓冲 channel 通常适用于消费者和生产者以相同速率工作但输出不稳定的情况。它是尖峰的，缓冲平滑了波峰和波谷。)

考虑到这一点，我建议最好明确管理您不想要所有值的事实。

这是 getRandomInt() 函数的更新版本。请注意在顶部使用 defer 的上下文取消设置，以及在发送时使用 select 语句。

func getRandomInt() (int, error) {
    ctx := context.Background() // creates a fresh, empty context
    ctx, cancel := context.WithCancel(ctx)
    defer cancel() // cancels the context when getRandomInt() returns

    ch := make(chan int)

    // 10 senders
    for i := 0; i < 10; i++ {
        go func(i int) {
            defer fmt.Printf("Goroutine #%d finished\n", i)
            fmt.Printf("Goroutine #%d started\n", i)

            data := heavyJob()

            // this select statement wil block until either this goroutine 
            // is the first to send, or the context is cancelled. In which case
            // another routine has already sent and it can discard it's values.
            select { 
            case ch <- data:
                fmt.Printf("Goroutine #%d sent data %d to ch\n", i, data)
            case <-ctx.Done():
                fmt.Printf("Goroutine #%d did not send, context is cancelled, would have sent data %d to ch\n", i, data)
            }
        }(i)
    }

    // 1 receiver
    timeout := time.After(2000 * time.Millisecond)
    select {
    case value := <-ch:
        // uses only the value received first, the rest are discarded
        return value, nil
    case <-timeout:
        return -1, errors.New("Timeout")
    }
}

设置带有取消的上下文意味着一旦调用 cancel() 函数，上下文就会变为“完成”。这是一种告诉所有发送者 goroutines 不要费心等待发送的方法。

发送时，select 语句阻塞，直到上下文被 cancel() 函数取消；或者接收方方法读取第一个值。

我还从 channel 中删除了缓冲，因为不再需要它了。

关于go - 在没有接收方的情况下，是否可以保留数据打开的缓冲 channel ？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/50616147/