Ist das Starten von Goroutines innerhalb von Goroutines akzeptabel?

Question

Ich lerne gerade jetzt mit und eines meiner ersten Projekte ist ein einfaches Ping-Skript. Im Wesentlichen möchte ich eine Reihe von URLs pingen, und auf die Antwort von jedem warten XXX Anzahl von Sekunden, dann erneut pingen. Hier ist der gekürzte Code:

func main() { 
    // read our text file of urls 
    f, err := ioutil.ReadFile(urlFile) 
    if err != nil { 
     log.Print(err) 
    } 

    urlStrings := []string{} 
    urlStrings = strings.Split(string(f), "\n") 

    for _, v := range urlStrings { 
     go ping(v) 
    } 

    // output logs to the terminal 
    // channel is global 
    for i := range c { 
     fmt.Println(i) 
    } 
} 

func ping(url string) { 
    // for our lag timer 
    start := time.Now() 

    // make our request 
    _, err := http.Get(url) 

    if err != nil { 
     msg := url + " Error:" + err.Error() 

     fmt.Println(msg) 

     c <- msg 
     reportError(msg) 
    } else { 
     lag := time.Since(start) 
     var msg string 

     // running slow 
     if lag > lagThreshold*time.Second { 
      msg = url + " lag: " + lag.String() 
      reportError(msg) 
     } 

     msg = url + ", lag: " + lag.String() 
     c <- msg 
    } 

    time.Sleep(pingInterval * time.Second) 
    go ping(url) // is this acceptable? 
} 

Auf meiner Get-Anfrage ich vorher rief aufschieben res.Body.Close(), aber das war panicing nach der App für eine Weile lief. Ich nahm an, dass die Verzögerung die Close() auf der Antwort nicht aufrufen konnte, bis die Goroutine Müll gesammelt worden war und die res nicht mehr existierte.

Das brachte mich zum Nachdenken, ob das Aufrufen einer Goroutine innerhalb einer Goroutine Best Practice war oder ob ich die Funktion niemals beenden würde, und dann würde ein Defer nur aufgerufen werden, sobald die Goroutine Müll gesammelt wurde.

Answer 1

Das ist in Ordnung. Es ist durchaus akzeptabel, eine Goroutine von einer anderen Goroutine aus aufzurufen. Die aufrufende Goroutine wird immer noch verlassen und die neue Goroutine wird auf ihren fröhlichen Weg gehen.

Answer 2

Eine neue Goroutine innerhalb einer Goroutine zu spannen ist per se völlig in Ordnung.

Aber ich bezweifle, dass dies die einfachste und sauberste Lösung für Ihr Problem ist. Ich vermute, dass Ihre erste Version das Offensichtliche getan hat und jede URL in einer Endlosschleife pingt. Und diese Bisse verzögern: Aufgeschobene Aufrufe werden ausgeführt, sobald die Funktion zurückgibt. (Das hat nichts mit einer Goroutine zu tun, die "Müll sammelt; eigentlich enden die Gorutiere einfach, die werden nicht eingesammelt.) In einer Endlosschleife kommt man nie zurück, man sammelt nur abgelehnte Anrufe, die nie ausgeführt werden. Man schließt also nie alle offenen res.Body und Sie laufen aus dem Speicher/was auch immer, und eine Panik sehen.

Doing defer res.Body.Close eine schöne Idiom ist, aber nicht in einer Endlosschleife.

ich würde versuchen, die erste Version und direkt ausführen res.Body Schließen Sie auf dem Null-Fehlerpfad