Parallelität, Goroutinen und Kanäle in Go: Eine Studie

Dieser Artikel untersucht die Genauigkeitsfunktionen von Go und konzentriert sich auf Goroutinen und Kanäle. Die Parallelität ermöglicht es anscheinend gleichzeitig mit mehreren Aufgaben zu handhaben, wenn auch nicht unbedingt gleichzeitig. Goroutines, die leichten Threads von GO werden mit dem Schlüsselwort go erstellt, wodurch gleichzeitige Vorgänge ermöglicht werden. Kanäle erleichtern die Kommunikation und Synchronisation zwischen Goroutinen und ermöglichen den Datenaustausch. Durch das Senden von Daten verwendet ch <- value, während das Empfangen verwendet value := <- ch.

Ein Docker-Pull-ähnliches Beispiel demonstriert diese Konzepte:

package main

import (
    "fmt"
    "math/rand"
    "os"
    "strconv"
    "sync"
    "time"
)

func main() {
    rand.Seed(time.Now().UnixNano())

    concurrency, _ := strconv.Atoi(os.Args[1]) // Get concurrency level from command line

    if concurrency <= 0 {
        concurrency = 100 // Default concurrency
    }

    progress := make([]int, concurrency)
    var mu sync.Mutex
    var wg sync.WaitGroup
    wg.Add(concurrency)

    for i := 0; i < concurrency; i++ {
        go func(idx int) {
            defer wg.Done()
            for progress[idx] < 100 {
                mu.Lock()
                if progress[idx] >= 100 {
                    mu.Unlock()
                    break
                }
                inc := rand.Intn(10) + 1
                progress[idx] += inc
                if progress[idx] > 100 {
                    progress[idx] = 100
                }
                mu.Unlock()
                time.Sleep(time.Duration(rand.Intn(400)+100) * time.Millisecond)
            }
        }(i)
    }

    done := make(chan struct{})
    go func() {
        wg.Wait()
        close(done)
    }()

    <-done // Wait for all goroutines to complete

    fmt.Println("Progress:", progress)
}

Das Programm simuliert gleichzeitige Aufgaben. Jede Goroutine aktualisiert seinen Fortschritt bis zum Abschluss. Ein Mutex sorgt für die Aktualisierung der gemeinsamen Fortschrittswerte der Thread. Eine Karteigruppe synchronisiert die Goroutine -Fertigstellung.

Schlüsselerlernen

Das Beispiel zeigt die Verwendung des Schlüsselworts go für die Erstellung von Goroutine und die gleichzeitige Verarbeitung. Es zeigt, wie Goroutinen gleichzeitig mehrere Fortschrittsindikatoren umgehen.

Weitere Erkundung

Diese Erkundung wirft Fragen zur Funktionalität von WaitGroup auf die Funktionalität von Wait auf (Inkrementierung/Verkleinerung der Zähler und das Blockieren mit go test -race), Mutexes (Verhinderung von Rassenbedingungen) und die Folgen des Auslassens. Die

Flagge zur Erkennung von Rassenbedingungen rechtfertigt weitere Untersuchungen.

Das obige ist der detaillierte Inhalt vonParallelität, Goroutinen und Kanäle in Go: Eine Studie. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!