Go 将值发送到 Channel 并在就绪时读取输出

让我与您分享一个您可以从中受益的工作示例.首先，我将介绍代码，然后，我将向您介绍所有相关部分.

package main

import (
    "fmt"
    "net/http"
    "os"
    "strings"
    "time"
)

type Request struct {
    Url            string
    DelayInSeconds time.Duration
}

type Response struct {
    Url        string
    StatusCode int
}

func main() {
    requests := []Request{
        {"https://www.google.com", 0},
        {"https://stackoverflow.com", 1},
        {"https://www.wikipedia.com", 4},
    }

    respChan := make(chan Response)
    defer close(respChan)

    for _, req := range requests {
        go func(r Request) {
            fmt.Printf("%q - %v\n", r.Url, strings.Repeat("#", 30))
            // simulate heavy work
            time.Sleep(time.Second * r.DelayInSeconds)
            resp, _ := http.Get(r.Url)
            res := Response{r.Url, resp.StatusCode}
            fmt.Println(time.Now())
            respChan <- res
        }(req)
    }

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

    for i := 0; i < len(requests); i++ {
        select {
        case res := <-respChan:
            go func(r Response) {
                f, err := os.Create(fmt.Sprintf("%v.txt", strings.Replace(r.Url, "https://", "", 1)))
                if err != nil {
                    panic(err)
                }
                defer f.Close()
                f.Write([]byte(fmt.Sprintf("%q OK with %d\n", r.Url, r.StatusCode)))
                writeChan <- struct{}{}
            }(res)
        case <-time.After(time.Second * 2):
            fmt.Println("Timeout")
        }
    }
}

设好

首先，我定义了本例中将使用的两个 struct :Request和Response.在前者中，我放了一个DelayInSeconds来模拟一些繁重和耗时的操作.然后，我定义了requests变量，它包含必须完成的所有请求.

写作部分

在这里，我的范围超过了requests变量.对于每个请求，我将向目标URL发出一个HTTP请求.time.Sleep模拟了沉重的负荷.然后，我将响应写入未缓冲的respChan通道.

阅读部分

这里的主要变化是将select struct 包装到for循环中.多亏了这一点，我们将确保迭代正确的时间(基于requests变量的长度).

结束语

First of all, bear in mind that the code is oversimplified just to show off the relevant parts. Due to this, a lot of error handling is missing and some inline functions could be extrapolated into named functions. You don't need to use sync.WaitGroup to achieve what you need, the usage of channels will be enough.
Feel free to play with delays and check which files are written!

如果这对你有帮助，请让我知道！

编辑

按照您的要求，我将根据您的需求为您提供更准确的解决方案.新的阅读部分将如下所示:

count := 0
for {
    // this check is need to exit the for loop and not wait indefinitely
    // it can be removed based on your needs
    if count == 3 {
        fmt.Println("all responses arrived...")
        return
    }
    res := <-respChan
    count++
    go func(r Response) {
        f, err := os.Create(fmt.Sprintf("%v.txt", strings.Replace(r.Url, "https://", "", 1)))
        if err != nil {
            panic(err)
        }
        defer f.Close()
        f.Write([]byte(fmt.Sprintf("%q OK with %d\n", r.Url, r.StatusCode)))
        writeChan <- struct{}{}
    }(res)
}

在这里，执行在for循环内无限期地等待.无论每个请求需要多长时间才能完成，它一到达就会被获取.我将if放在for循环的顶部，在它处理了我们需要的请求后退出.但是，您可以避免它，并让代码运行，直到收到取消信号(由您决定).

如果这更符合您的要求，请让我知道，谢谢！