Как правильно настроить канал в Golang?

Question

[Pryby]

Подскажите пожалуйста где мне тут поправить, что бы у меня в итоге функции ждали друг друга, main заканчивается и не успевают наполнится мапы

package main

import (
    "flag"
    "fmt"
    "log"
    "net/http"
    "strings"
    "time"
)

type inputDataStruct struct {
    url           []string
    count         int
    timeOut       int
    dataResponses map[string][]float64
    noResponses   map[string]int
}

func getResponse(urlChan chan string, inputData inputDataStruct) {
    url := <-urlChan
    start := time.Now()
    client := http.Client{
        Timeout: time.Duration(inputData.timeOut) * time.Second,
    }
    result, err := client.Get(url)
    if err != nil {
        inputData.noResponses[url] = inputData.noResponses[url] + 1
        log.Fatal(err)
    }
    elapsed := time.Since(start).Seconds()
    defer result.Body.Close()
    s := fmt.Sprintf("%s %f", url, elapsed)
    log.Println(s)
    if result.StatusCode == http.StatusOK {
        go appendResponse(urlChan, elapsed, inputData)
        urlChan <- url
    }
}

func appendResponse(urlChan chan string, time float64, inputData inputDataStruct) {
    inputData.dataResponses[<-urlChan] = append(inputData.dataResponses[<-urlChan], time)
}

func httpRequest(waitChan chan struct{}, inputData inputDataStruct) {
    //url := <- urlChan
    defer close(waitChan)
    urlChan := make(chan string)
    count := inputData.count
    j := 0
    for i := range inputData.url {
        for j < count {
            go getResponse(urlChan, inputData)
            urlChan <- inputData.url[i]
            j++
        }
        j = 0
    }

}

func parseArgument(item string) []string {
    return strings.Split(item, ",")
}
func findMinMaxAvg(values []float64) (min float64, max float64, avg float64) {
    if len(values) == 0 {
        return 0, 0, 0
    }

    min = values[0]
    max = values[0]
    var sum float64 = 0
    for _, v := range values {
        if v < min {
            min = v
        }
        if v > max {
            max = v
        }
        sum = sum + v
    }
    var count = float64(len(values))
    avg = sum / count
    return min, max, avg
}

func printMinMaxAvg(dataResponses map[string][]float64) {
    for key, _ := range dataResponses {
        min, max, avg := findMinMaxAvg(dataResponses[key])
        fmt.Printf("url: %s, min: %f, max: %f, avg: %f \n", key, min, max, avg)

    }
}

func main() {
    //urlArrChan := make(chan []string)
    waitChan := make(chan struct{})
    //var dataResponses = map[string][]float64{}
    //var noResponses = map[string]int{}
    url := flag.String("url", "", "url.")
    count := flag.Int("count", 1, "count response.")
    timeout := flag.Int("timeout", 1, "count response.")
    flag.Parse()
    var inputData inputDataStruct
    inputData.count = *count
    inputData.timeOut = *timeout
    inputData.dataResponses = map[string][]float64{}
    inputData.noResponses = map[string]int{}
    //inputData.urlChan = make(chan string)
    //inputData.syncChan = make(chan struct{})
    inputData.url = parseArgument(*url)
    //inputValue := parseArgument(*url)
    start := time.Now()
    //i := 0
    go httpRequest(waitChan, inputData)
    //urlArrChan <- inputValue
    <-waitChan
    //for i := range inputValue {
    //  //fmt.Print(inputValue[i])
    //  inputData.url = inputValue[i]
    //  httpRequest(inputData)
    //  //urlChan<-inputValue[i]
    //  i++
    //}
    elapsed := time.Since(start).Seconds()
    //<-inputData.urlChan
    //time.Sleep(1 * time.Second)
    fmt.Println(inputData.dataResponses)
    printMinMaxAvg(inputData.dataResponses)
    fmt.Printf("Total time: %f \n", elapsed)
    fmt.Println(inputData.noResponses)
    fmt.Scanln()
}

Comments

[12rbah]

Решение вам уже написали. В целом вам нет смысла вызывать столько горутин, достатоточно вызывать по одной на url, прочитайте пару статей про waitGroup, и первую главу кернигана, у него реализована похожая программа, но сделана гораздо проще.

Answer 1

[Владислав]

Вам нужно добавить sync.WaitGroup во внутрь функции httpRequest

Получиться приблизительно так:

func httpRequest(waitChan chan struct{}, inputData inputDataStruct) {
    //url := <- urlChan
    defer close(waitChan)
    urlChan := make(chan string)
    count := inputData.count
    j := 0
    var wg sync.WaitGroup
    for i := range inputData.url {
        for j < count {
            wg.Add(1)
            go func() {
getResponse(urlChan, inputData)
wg.Done()
}
            urlChan <- inputData.url[i]
            j++
        }
        j = 0
    }
wg.Wait()
}

Я конечно не уверен, что ваш код станет после этого рабочим, так как у вас там дальше запускаются горутины, например appendResponse(), только не понятно зачем.

Comments

[Pryby]

вообще сначала без горутины было, это я уже пробовал. Сейчас попробую ваш способ

[Pryby]

wg.Wait() застревает и стоит ждет

[Владислав]

Pryby, так и должно быть.
Пока не выполнится wg.Done() равным кол-ву wg.Add(), wg.Wait() будет ждать.
То есть, в вашем случае, застревает где-то в getResponse().

[Pryby]

Владислав, go func() {
getResponse(urlChan, inputData)
wg.Done()
}() <- только я скобки добавил, без них не запускается
так вроде response выполняется, вызовы выводит и потом ждет wait, не совсем понимаю почему не пропускает.

[Pryby]

Владислав, а как исправить это можно, подскажите ?

[Pryby]

Владислав, вроде сработало, спасибо)

[Владислав]

Pryby, а у вас дважды пишется в канал urlChan, но не читается в этот же момент.
Так как канал не буферизированный, в него можно записать только 1 раз и он будет ждать, пока из него считают.
Думаю, у вас происходит дважды запись в канал,
сначала в функции httpRequest() - `urlChan <- inputData.url[i]`
а потом в функции getResponse() - `urlChan <- url`
И происходит дедлок.

Думаю, вам нужно сначала написать код без горутин и многопотока, а только после получения работоспособного кода, его улучшать.
Например, зачем передавать канал в функцию getResponse и читать его, когда можно сразу передать текст со ссылкой.

[Pryby]

Владислав, нужно просто что бы паралельно запросы были все и я пытался добиться того, что бы main ждал выполнения сначала всех этих запросов и наполнения мап, только потом продолжал, поэтому я пробовал так. Не знаю если честно как через канал синхронизировать правильно в данном случае

[Pryby]

Владислав, в функции getResponse() - `urlChan <- url` я удалил уже, заработало без этого

[Владислав]

Pryby, напишите сначала без каналов, чтобы работало, потом пробросите канал чтобы возвращать результат из функции.
Вам нужен всего один канал который вы передадите в getResponse()
waitChan вам не нужен, так как wg будет ждать.

Так же из канала, в который вы пишете, нужно сразу же считывать данные в другой горутине, так как нельзя просто писать в канал, из него необходимо сразу же считывать.

[Владислав]

Pryby, посмотрите как сделано тут.
Лучший способ избежать race condition, в данном случае?