將值發送到 Channel 並在就緒時讀取 output

Question

我正在嘗試使用 Golang 中的兩個通道構建接收方和發送方模式。 我正在執行一項任務（API 調用），並收到一個Response結構。 我的目標是，當收到響應時，我想將其發送到另一個通道 ( writeChan ) 以進行額外處理。

我想持續讀取/收聽該接收通道 ( respChan ) 並處理通過的任何內容（例如Response ）。 然后我想啟動一個線程到 go 並在另一個 goroutine 中對該 Response 做進一步的操作。

我想了解如何將此模式鏈接在一起以允許數據從 API 調用流出並同時寫入它（每個響應將寫入Write()函數處理的單獨文件目標。

基本上我目前的模式如下：

package main

import (
    "fmt"
    "sync"
)

func main() {

    var wg sync.WaitGroup
    respChan := make(chan Response) // Response is a struct that contains API response metadata
    defer close(respChan)
    // requests is just a slice of requests to be made to an API
    // This part is working well
    for _, req := range requests {
        wg.Add(1)
        go func(r Request) {
            defer wg.Done()
            resp, _ := r.Get() // Make the API call and receive back a Response struct
            respChan <- resp // Put the response into our channel
        }(req)
    }

    // Now, I want to extract the responses as they become available and send them to another function to do some processing. This I am unsure of how to handle properly
    writeChan := make(chan string)
    defer close(writeChan)
    select {
        case resp := <-respChan: // receive from response channel
            go func(response Response) {
                signal, _ := Write(response) // Separate func to write the response to a file. Not important here in this context.
                writeChan <- signal // Put the signal data into the channel which is a string file path of where the file was written (will be used for a later process)

            }(resp)
        case <-time.After(15 *time.Second):
            fmt.Println("15 seconds have passed without receiving anything...")

    }
    wg.Wait()
}

Answer 1

讓我與您分享一個您可以從中受益的工作示例。 首先，我將展示代碼，然后，我將引導您完成所有相關部分。

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")
        }
    }
}

設置

首先，我定義了將在示例中使用的兩個結構： Request和Response 。 在前者中，我放了一個DelayInSeconds來模擬一些重負載和耗時的操作。 然后，我定義了包含所有必須完成的請求的requests變量。

寫作部分

在這里，我檢查了requests變量。 對於每個請求，我將向目標 URL 發出 HTTP 請求time.Sleep模擬重負載。 然后，我將響應寫入無緩沖的respChan通道。

閱讀部分

在這里，主要的變化是將select構造包裝到一個for循環中。 多虧了這一點，我們將確保迭代正確的時間（基於requests變量的長度）。

最后的筆記

首先，請記住代碼過於簡單只是為了展示相關部分。 因此，缺少很多錯誤處理，一些內聯函數可以外推到命名函數中。 你不需要使用sync.WaitGroup來實現你需要的，使用通道就足夠了。
隨意玩延遲並檢查寫入了哪些文件！

讓我知道這是否對您有幫助！

編輯

根據要求，我將根據您的需求為您提供更准確的解決方案。 新的閱讀部分將類似於以下內容：

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循環中無限期地等待。 無論每個請求需要多長時間才能完成，它都會在到達時立即獲取。 我在for循環的頂部放置了一個if語句，以便在它處理完我們需要的請求后退出。 但是，您可以避免它並讓代碼運行直到出現取消信號（由您決定）。

讓我知道這是否更符合您的要求，謝謝！