Golang-Programmierpraxis mit hoher Parallelität: Verwendung von Goroutinen zur Leistungsoptimierung

Golang-Programmierpraxis mit hoher Parallelität: Verwendung von Goroutinen zur Leistungsoptimierung

Einführung:
In der heutigen Softwareentwicklung ist hohe Parallelität zu einem sehr wichtigen Thema geworden. Mit der Entwicklung von Internetanwendungen und der Zunahme der Benutzerbesuche ist es zum Standard geworden, eine große Anzahl gleichzeitiger Anfragen gleichzeitig zu bearbeiten. Als Reaktion auf diese Anforderungen ist Golang als effiziente, prägnante Sprache mit hervorragender Parallelitätsleistung natürlich zur ersten Wahl für Entwickler geworden.

Dieser Artikel konzentriert sich auf Golangs Programmierung mit hoher Parallelität und stellt praktische Erfahrungen zur Verwendung von Goroutinen zur Leistungsoptimierung vor. Anhand von Codebeispielen zeigen wir Schritt für Schritt, wie man Goroutinen verwendet, um den Durchsatz und die Reaktionsgeschwindigkeit des Programms zu verbessern.

1. Der Unterschied zwischen Parallelität und Parallelität. Bevor wir beginnen, werfen wir einen Blick auf die Konzepte von Parallelität und Parallelität. Parallelität bezieht sich auf zwei oder mehr Ereignisse, die innerhalb desselben Zeitraums, jedoch nicht unbedingt gleichzeitig, auftreten. Parallelität bezieht sich auf zwei oder mehr Ereignisse, die zum gleichen Zeitpunkt auftreten. Mit anderen Worten: Parallelität ist die abwechselnde Ausführung mehrerer Ereignisse innerhalb eines Zeitraums, während Parallelität die gleichzeitige Ausführung mehrerer Ereignisse zum gleichen Zeitpunkt ist.

Golang implementiert eine Programmierung mit hoher Parallelität über Goroutinen und Kanäle. Goroutinen sind leichtgewichtige Threads, deren Erstellung und Zerstörung kostengünstiger ist als System-Threads. Kanäle sind ein Mechanismus zur Kommunikation zwischen Goroutinen, der Daten sicher zwischen mehreren Goroutinen übertragen kann.

2. Beispielcode: Berechnung der Fibonacci-Folge

Wir zeigen anhand eines einfachen Beispiels, wie man mit Goroutinen eine Leistungsoptimierung erreicht. Wir werden ein Programm schreiben, das die N-te Zahl der Fibonacci-Folge berechnet.

package main

import (

"fmt"
"time"

)

// Rekursive Berechnung der Fibonacci-Folge

func fibonacci(n int) int {

if n <= 2 {
    return 1
}
return fibonacci(n-1) + fibonacci(n-2)

}

func main() {

n := 40
start := time.Now()

// 串行计算斐波那契数列
result := fibonacci(n)

elapsed := time.Since(start)
fmt.Printf("Serial: Result: %d, Time taken: %s

", result, elapse d)

// 并行计算斐波那契数列
ch := make(chan int)
go fibonacciParallel(n, ch)

// 通过Channel接收并行计算的结果
resultParallel := <-ch
fmt.Printf("Parallel: Result: %d, Time taken: %s

", resultParallel, elapsed)

}

func fibonacciParallel(n int, ch chan int) {

ch <- fibonacci(n)

}

Im obigen Beispielcode definieren wir eine Fibonacci-Funktion, die rekursiv berechnet wird. Die N-te Zahl in die Fibonacci-Folge. Zum Vergleich mit der parallelen Berechnung verwenden wir zunächst die serielle Methode zur Berechnung der Fibonacci-Folge und geben die Berechnungsergebnisse und die Ausführungszeit aus.

Als nächstes haben wir die fibonacciParallel-Funktion definiert und Goroutinen verwendet, um paralleles Rechnen zu implementieren. Wir erstellen einen Kanal ch und senden die Berechnungsergebnisse der Fibonacci-Funktion an ch. In der Hauptfunktion erhalten wir die Ergebnisse der Parallelberechnung, indem wir Daten von ch empfangen.

3. Wenn wir uns vergleichen, ist ersichtlich, dass die Ergebnisse der parallelen Berechnung mit den Ergebnissen der seriellen Berechnung übereinstimmen. Gleichzeitig stellen wir fest, dass die Zeit paralleler Berechnungen fast gleich der Zeit serieller Berechnungen ist. Dies liegt daran, dass wir beim Erhalten paralleler Berechnungsergebnisse immer noch die serielle Methode verwenden.

4. Optimierung des parallelen Rechnens

Um Goroutinen wirklich zur Leistungsoptimierung zu nutzen, müssen wir die Methode des parallelen Rechnens anpassen. Wir können die Wartegruppe verwenden, um zu warten, bis alle Goroutinen die Berechnungen abgeschlossen haben, bevor wir die Ergebnisse erhalten.

package main

import (

"fmt"
"sync"
"time"

)

func main() {

n := 40
start := time.Now()

// 并行计算斐波那契数列
resultParallel := fibonacciParallel(n)

elapsed := time.Since(start)
fmt.Printf("Parallel: Result: %d, Time taken: %s

", resultParallel, elapsed)

}

func fibonacciParallel(n int) int {

var wg sync.WaitGroup
ch := make(chan int)

wg.Add(1)
go func() {
    defer wg.Done()
    ch <- fibonacci(n)
}()

// 等待所有的Goroutines完成
wg.Wait()

resultParallel := <-ch
return resultParallel

}

durch die oben genannte Optimierung , Wir verwenden WaitGroup im Synchronisierungspaket, um auf den Abschluss aller Goroutinen zu warten, um sicherzustellen, dass die Ressourcen korrekt freigegeben werden, wenn die Funktion beendet wird

Nach der Optimierung. Code können wir die folgenden laufenden Ergebnisse erhalten:

Parallel: Ergebnis: 165580141, benötigte Zeit: 10,343731 ms

Sie können sehen, dass die Zeit der optimierten parallelen Berechnung fast der Zeit der vorherigen seriellen Berechnung entspricht Das Erstellen und Zerstören von Goroutinen ist sehr gering, sodass sich der Zeitaufwand für paralleles Rechnen nicht wesentlich erhöht.

Fazit:

Dieser Artikel stellt es anhand von Codebeispielen vor Mithilfe von Goroutinen können wir auf einfache Weise paralleles Rechnen in Golang implementieren und so den Durchsatz und die Reaktionsgeschwindigkeit des Programms verbessern. Gleichzeitig haben wir auch die Verwendung von Wartegruppen zur Optimierung eingeführt Paralleles Rechnen.

In der tatsächlichen Anwendungsentwicklung können wir die gleichzeitige Rechenmethode entsprechend den tatsächlichen Anforderungen und Szenarien weiter optimieren, indem wir die Leistung und Skalierbarkeit des Systems verbessern Bessere Dienste. Ich hoffe, dieser Artikel kann Sie inspirieren und Ihnen dabei helfen, Goroutinen für die Programmierung mit hoher Parallelität in tatsächlichen Projekten optimal zu nutzen.

Das obige ist der detaillierte Inhalt vonGolang-Programmierpraxis mit hoher Parallelität: Verwendung von Goroutinen zur Leistungsoptimierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!