Wie kann ich aktive Goroutinen in Go effizient zählen und verwalten?

Aktive Goroutinen zählen

Bei der gleichzeitigen Verwaltung mehrerer Goroutinen ist es oft notwendig, die Anzahl der aktiven zu überwachen. In Go stellt die native runtime.NumGoroutine()-Funktion diese Informationen bereit.

Betrachten Sie das folgende Beispiel:

var element int

func deen(queue chan int) {

    element := <-queue
    fmt.Println("element is ", element)
    if element%2 == 0 {
        fmt.Println("new element is ", element)
        queue <- (element*100 + 11)
        queue <- (element*100 + 33)
    }
}

func main() {
    queue := make(chan int, 10)
    queue <- 1
    queue <- 2
    queue <- 3
    queue <- 0
    for len(queue) != 0 {
        for i := 0; i < 2; i++ {
            go deen(queue)
        }
    }
    fmt.Scanln()
    fmt.Println("list has len", len(queue)) //this must be 0
}

Dieser Code demonstriert zwar die Verwendung von Goroutinen, bietet jedoch keine Möglichkeit um die Anzahl der aktiven Goroutinen zu einem bestimmten Zeitpunkt zu zählen.

Um dieses Problem zu beheben, besteht ein effizienterer Ansatz darin, eine sync.WaitGroup zu verwenden, die koordiniert den Abschluss mehrerer Goroutinen.

func deen(wg *sync.WaitGroup, queue chan int) {
    for element := range queue {
        fmt.Println("element is ", element)
        if element%2 == 0 {
            fmt.Println("new element is ", element)
            wg.Add(2)
            queue <- (element*100 + 11)
            queue <- (element*100 + 33)
        }
        wg.Done()
    }
}

func main() {
    var wg sync.WaitGroup
    queue := make(chan int, 10)
    queue <- 1
    queue <- 2
    queue <- 3
    queue <- 0
    for i := 0; i < 4; i++ {
        wg.Add(1)
        go deen(&wg, queue)
    }
    wg.Wait()
    close(queue)
    fmt.Println("list has len", len(queue)) //this must be 0

}

In diesem modifizierten Code wird die sync.WaitGroup verwendet, um die Anzahl der aktiven Goroutinen zu verfolgen. Jede Goroutine verringert den Zähler nach Abschluss, und die Haupt-Goroutine wartet, bis die Ausführung aller Goroutinen abgeschlossen ist, bevor sie fortfährt.

Durch die Nutzung von runtime.NumGoroutine() oder der effizienteren sync.WaitGroup können Go-Programmierer effektiv überwachen und verwalten die aktiven Goroutinen in ihren Anwendungen.

Das obige ist der detaillierte Inhalt vonWie kann ich aktive Goroutinen in Go effizient zählen und verwalten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!