Warten Sie, bis die Kündigung von n goroutines

Brauche ich eine riesige Menge von goroutines und warten auf Ihre Kündigung. Die intuitive Art und Weise, scheint ein Kanal zu warten, bis alle fertig sind :

package main

type Object struct {
    //data
}

func (obj *Object) Update(channel chan int) {
    //update data
    channel <- 1
    return
}

func main() {

    channel := make(chan int, n)
    list := make([]Object, n, m)
    for {
        for _, object := range list {
            go object.Update(channel)
        }
        for i := 0; i < n; i++ {
            <-channel
        }
        //now everything has been updated. start again
    }
}

Aber das problem ist, dass die Menge der Objekte und damit die Menge der goroutines ändern könnte. Ist es möglich, ändern Sie die Puffergröße ein Kanal ?

Gibt es vielleicht eine elegantere Möglichkeit das zu tun ?

Sie könnte den Puffer in jeder iteration, aber möchten Sie vielleicht, zu betrachten, WaitGroup.
tjameson, vielen Dank für die schnelle Hilfe. Das sieht wirklich gut aus. Sie wollen vielleicht machen Sie es eine Antwort.
Getan, mit ein Beispiel =D
möglich, Duplikat der Wie warten Sie, bis alle goroutines zu beenden, ohne mit der Zeit.Schlafen?

InformationsquelleAutor lhk | 2013-05-16

Ich verwendet habe, WaitGroup als eine Lösung für dieses problem. Übersetzen Sie Ihre aktuelle code, mit einigen logs deutlich zu machen, was passiert:

package main

import "sync"
import "fmt"
import "time"

type Object struct {
    //data
}

func (obj *Object) Update(wg *sync.WaitGroup) {
    //update data
    time.Sleep(time.Second)
    fmt.Println("Update done")
    wg.Done()
    return
}

func main() {
    var wg sync.WaitGroup
    list := make([]Object, 5)
    for {
        for _, object := range list {
            wg.Add(1)
            go object.Update(&wg)
        }
        //now everything has been updated. start again
        wg.Wait()
        fmt.Println("Group done")
    }
}

Nette Antwort! Ich würde wahrscheinlich setzen defer wg.Done() am Anfang Update aber nur im Fall, dass die Funktion wächst und gewinnt eine baldige Rückkehr irgendwann in der Zukunft.
Oder im Fall einer Panik oder so etwas.

InformationsquelleAutor beatgammit

4

Diese Aufgabe nicht gerade trivial, es ist ganz einfach, Schreibe einen buggy ein. Ich empfehle eine fertige Lösung in der stdlib - sync.WaitGroup. Zitat aus dem link:

Einen WaitGroup wartet eine Sammlung von goroutines zu beenden. Die wichtigsten goroutine Anrufe Hinzufügen, um die Anzahl von goroutines zu warten. Die goroutines läuft, und fordert Sie am Ende auf fertig. Zur gleichen Zeit, Warten können verwendet werden, zu blockieren, bis alle goroutines abgeschlossen haben.
- Und wenn die Anzahl von goroutines zu warten, ist nicht im Voraus bekannt ?
- Sie erhöhen den Zähler, wenn Sie beginnen jede goroutine, weshalb diese Lösung ist immer noch die beste Lösung, wenn Sie nicht wissen, wie viele goroutines Sie werden.
InformationsquelleAutor zzzz

@tjameson hat einen tollen job zu erklären, wie zu verwenden WaitGroup, gewusst wie: übergeben Sie einen Verweis auf Ihre WaitGroup Objekt Ihrer Funktion. Die eine änderung, die ich machen würde, um sein Beispiel ist der Hebel defer wenn Sie Done. Ich denke, das defer ws.Done() sollte die erste Anweisung in der Funktion.

Ich mag WaitGroup's Einfachheit. Allerdings gefällt mir nicht, dass wir übergeben die Referenz auf die goroutine denn das würde bedeuten, dass die Parallelität Logik wäre gemischt mit Ihrer business-Logik.

So kam ich auf diese generische Funktion um dieses problem zu lösen für mich:

//Parallelize parallelizes the function calls
func Parallelize(functions ...func()) {
    var waitGroup sync.WaitGroup
    waitGroup.Add(len(functions))

    defer waitGroup.Wait()

    for _, function := range functions {
        go func(copy func()) {
            defer waitGroup.Done()
            copy()
        }(function)
    }
}

Also dein Beispiel konnte auf diese Weise gelöst werden:

type Object struct {
    //data
}

func (obj *Object) Update() {
    //update data
    time.Sleep(time.Second)
    fmt.Println("Update done")
    return
}

func main() {
    functions := []func(){}
    list := make([]Object, 5)
    for _, object := range list {
        function := func(obj Object){ object.Update() }(object)
        functions = append(functions, function)
    }

    Parallelize(functions...)        

    fmt.Println("Group done")
}

Wenn Sie möchten, es zu benutzen, finden Sie es hier https://github.com/shomali11/util

InformationsquelleAutor Raed Shomali

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.