Was ist die parallele Schreibmethode in Golang?

In der modernen Softwareentwicklung ist die effiziente Nutzung der Computerhardwareressourcen von entscheidender Bedeutung. Parallele Programmierung ist eine Programmiermethode, die die Nutzung von Multi-Core-CPUs maximieren kann. Im Vergleich zu anderen Programmiersprachen verfügt die Go-Sprache (auch Golang genannt) über integrierte Tools und Mechanismen zur Unterstützung der gleichzeitigen Programmierung und ist daher im Bereich der parallelen Programmierung weit verbreitet und anerkannt.

In diesem Artikel werden einige Methoden und Techniken zur Implementierung der parallelen Programmierung in Golang sowie deren anwendbare Szenarien und Vorsichtsmaßnahmen vorgestellt.

1. Goroutine und Channel

Goroutine ist ein paralleles Programmiermodell, das Golang von anderen Programmiersprachen übernimmt. Es wird als Lightweight-Thread bezeichnet und nutzt die Multi-Core-Rechenleistung Ihres Computers effizienter. Jede Goroutine wird automatisch vom Golang-Laufzeitsystem verwaltet, und Entwickler müssen lediglich eine Goroutine erstellen, indem sie das Schlüsselwort go ausführen.

Zum Beispiel:

func main() {
    go func() {
        fmt.Println("Hello, Goroutine!")
    }()
    fmt.Println("Hello, World!")
}

In diesem Code erstellen wir eine anonyme Funktion und konvertieren sie mithilfe des Schlüsselworts go in eine Goroutine. Das Programm gibt gleichzeitig „Hallo, Welt!“ und „Hallo, Goroutine!“ aus.

Channel ist der Mechanismus in Golang für die Kommunikation zwischen Goroutinen. Der Kanal kann zur Übertragung beliebiger Datentypen verwendet werden, sodass Daten und Steuerinformationen zwischen verschiedenen Goroutinen übertragen werden können.

Zum Beispiel:

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started  job", j)
        time.Sleep(time.Second)
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)
    for a := 1; a <= 9; a++ {
        <-results
    }
}

In diesem Code definieren wir eine Worker-Funktion, die zwei Kanäle empfängt: einen zum Empfangen von Aufgaben und einen zum Zurückgeben von Aufgabenergebnissen. Wir haben drei Goroutinen erstellt. Jede Goroutine erhält Aufgaben vom Job-Kanal und schreibt die Verarbeitungsergebnisse in den Ergebniskanal. Schließlich verwenden wir eine for-Schleife, um 9 Aufgaben an den Jobs-Kanal zu senden und die Werte des Ergebniskanals an die Standardausgabe auszugeben. Beachten Sie, dass wir den Job-Kanal nach der for-Schleife schließen müssen, damit die Worker-Funktion beendet wird.

2. Sync-Paket

In Golang stellt das Sync-Paket einige Synchronisierungstools bereit, die für die parallele Programmierung erforderlich sind, wie zum Beispiel:

· WaitGroup: Warten Sie, bis eine Gruppe von Goroutinen Aufgaben erledigt.
· Mutex: Implementieren Sie den gegenseitigen Ausschluss von Shared Datenzugriff;
· Cond: Bedingungsvariable, die für die Kommunikation und Synchronisierung zwischen mehreren Goroutinen verwendet wird.

Hier zeigen wir ein Beispiel für die Verwendung von WaitGroup:

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)

    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
}

In diesem Beispiel definieren wir eine Worker-Funktion, die einen WaitGroup-Zeiger als Parameter erhält. Nachdem die Funktionsarbeit abgeschlossen ist, rufen wir die Done-Methode von WaitGroup auf, um der Goroutine-Aufgabe, zu der sie gehört, mitzuteilen, dass sie abgeschlossen wurde. In der Hauptfunktion erstellen wir eine Goroutine für jede Worker-Funktion und teilen WaitGroup mit der Add-Methode von WaitGroup mit, dass hier eine Gruppe von Goroutinen ausgeführt wird. Schließlich rufen wir die Wait-Methode auf, um darauf zu warten, dass alle Goroutinen ihre Aufgaben abgeschlossen haben.

3. GOMAXPROCS festlegen

In Golang ist GOMAXPROCS eine Zahl, die angibt, wie viele Goroutinen gleichzeitig ausgeführt werden sollen. Wird diese Zahl zu klein eingestellt, wird die Parallelität des Programms eingeschränkt. Bei einer zu großen Einstellung werden Computerressourcen verschwendet. Daher müssen wir den Wert von GOMAXPROCS entsprechend der Anzahl der Prozessorkerne des Computers festlegen, um eine übermäßige oder unzureichende Auslastung der Computerressourcen zu vermeiden.

Standardmäßig entspricht GomaxPROCS der Anzahl der Prozessorkerne. Sie können es mit dem Laufzeitpaket im Programmcode ändern:

import "runtime"

//...

func main() {
    numCPU := runtime.NumCPU()
    runtime.GOMAXPROCS(numCPU)

    //...
}

Hier verwenden wir das Laufzeitpaket, um die Anzahl der Prozessorkerne zu ermitteln Setzen Sie den Wert von GOMAXPROCS auf die Anzahl der Kerne.

Zusammenfassung

In diesem Artikel werden verschiedene Methoden und Techniken der gleichzeitigen Programmierung in Golang vorgestellt, darunter Goroutine und Channel, Sync-Paket und die Einrichtung von GOMAXPROCS. Obwohl die gleichzeitige Programmierung die Programmleistung und -effizienz verbessern kann, birgt sie auch einige Risiken und Herausforderungen. Daher müssen wir bei der gleichzeitigen Programmierung eine geeignete Lösung basierend auf der tatsächlichen Situation auswählen und auf die Kontrolle des Parallelitätsgrads achten, um unnötige Fehler und Ressourcenverschwendung zu vermeiden.

Das obige ist der detaillierte Inhalt vonWas ist die parallele Schreibmethode in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!