Parallelitätsimplementierung in der Golang-Sprache

Golang ist eine von Google entwickelte Programmiersprache für serverseitige Anwendungen. Es zeichnet sich durch eine leistungsstarke Parallelitätsleistung aus und wird daher immer häufiger in verteilten Systemen und bei der Entwicklung groß angelegter Anwendungen mit hoher Parallelität eingesetzt. In diesem Artikel wird hauptsächlich die Implementierung der Parallelität in der Golang-Sprache vorgestellt.

1. Parallelität und Parallelität

Bevor wir über die gleichzeitige Implementierung von Golang sprechen, müssen wir die beiden Konzepte Parallelität und Parallelität verstehen. Parallelität bezieht sich auf die Fähigkeit, mehrere Aufgaben gleichzeitig auszuführen, möglicherweise innerhalb desselben Programms. Unter Parallelität versteht man die Fähigkeit, mehrere Aufgaben gleichzeitig auszuführen. Die Implementierung von Parallelität erfordert die Verwendung von Threads, Prozessen und anderen Mechanismen des Betriebssystems, während Parallelität die Verwendung von Hardwarefunktionen wie Multicore-CPUs erfordert. Einfach ausgedrückt wird die Parallelität von Golang in einem einzelnen Thread und die Parallelität in mehreren Threads implementiert.

2. Golangs Parallelitätsmodell

Golangs Parallelitätsmodell basiert auf den beiden Konzepten Goroutine und Channel. Goroutine ist ein von Golang bereitgestellter leichtgewichtiger Thread, der auf Coroutine-Basis implementiert ist. Im Vergleich zu Threads ist der Aufwand für das Erstellen und Zerstören von Goroutinen sehr gering, und auch der Aufwand für den Wechsel zwischen Goroutinen ist sehr gering. Daher kann eine große Anzahl von Goroutinen zur Ausführung von Aufgaben geöffnet werden, wodurch die Parallelitätsleistung der Anwendung verbessert wird.

Ebenso wichtig wie Goroutine ist der Kanal. Channel ist ein von Golang bereitgestellter threadsicherer Kommunikationsmechanismus. Über Channel können Goroutinen kommunizieren und die Ausführung koordinieren, um den Datenaustausch und die Zusammenarbeit zu erreichen und gleichzeitig Probleme wie Konkurrenz zu vermeiden, die bei der gleichzeitigen Ausführung mehrerer Threads auftreten können.

3. So erstellen und rufen Sie Goroutine auf

Goroutine kann mit dem Schlüsselwort go erstellt und aufgerufen werden. Das Folgende ist ein einfaches Beispiel:

func main() {
    go func() {
        fmt.Println("This is a Goroutine!")
    }()
    fmt.Println("This is the main function!")
    time.Sleep(time.Second)
}

Im obigen Beispiel haben wir das Schlüsselwort go verwendet, um eine Goroutine zu erstellen. Funktionen in Goroutine werden mithilfe anonymer Funktionen implementiert. Bevor die Zeichenfolge „Das ist eine Goroutine!“ ausgegeben wird, gibt das Programm zunächst die Zeichenfolge „Dies ist die Hauptfunktion!“ aus. Da Goroutine asynchron ausgeführt wird, wartet die Anwendung nicht auf die Ausführung von Goroutine, sondern wird direkt beendet. Wir können die Sleep-Funktion im Zeitpaket verwenden, um den Thread eine bestimmte Zeit warten zu lassen, damit Goroutine Zeit zur Ausführung hat.

4. Die Verwendung von Channel

Channel ist ein threadsicherer Kommunikationsmechanismus, der von Golang bereitgestellt wird. Es kann verwendet werden, um Informationen zu synchronisieren und Daten zwischen Goroutinen auszutauschen, um Wettbewerbsprobleme zwischen mehreren Goroutinen zu verhindern.

Die Verwendung von Channel ist sehr einfach. Zuerst müssen wir einen Kanal erstellen. Zum Erstellen eines Kanals muss der Typ der Elemente im Kanal angegeben werden. Das Folgende ist ein Beispiel für die Erstellung eines Kanals:

ch := make(chan int)

In diesem Beispiel verwenden wir die Make-Funktion, um einen Kanal mit Elementen vom Typ int zu erstellen.

Um Daten an den Kanal zu senden, können Sie die Sendemethode des Kanals aufrufen (mit dem <-Operator), wie unten gezeigt:

ch <- 10

In diesem Beispiel Wir senden Daten an den Kanal A Daten vom Typ int 10. Wenn der Kanal voll ist, wird der Vorgang blockiert, bis im Kanal Platz ist.

Um Daten von Channel zu empfangen, können Sie die Empfangsmethode von Channel aufrufen (mit dem <-Operator), wie unten gezeigt:

n := <-ch

In diesem Beispiel empfangen wir Daten von Kanal A Daten n vom Typ int. Wenn der Kanal leer ist, wird der Vorgang ebenfalls blockiert, bis Daten im Kanal vorhanden sind.

Channel verfügt auch über andere Operationen, z. B. die Close-Methode zum Schließen des Channels, die Len-Funktion zum Ermitteln der Anzahl der Elemente im Channel usw.

5. Golang-Parallelitätsprogrammierungsbeispiel

Im Folgenden verwenden wir ein einfaches Beispiel, um die Parallelitätsimplementierung von Golang zu demonstrieren.

Angenommen, wir müssen den Durchschnitt aller Elemente in einem Array berechnen. Aufgrund der großen Anzahl an Elementen im Array kann die Berechnung zeitaufwändig sein. Wir können den Parallelitätsmechanismus von Golang verwenden, um Berechnungen zu beschleunigen.

Zuerst definieren wir ein Array a mit 100 Elementen vom Typ int. Dann erstellen wir 10 Goroutinen, um den Wert jedes Elements in einem Array zu berechnen, und addieren schließlich die Summe aller Elemente und dividieren durch die Anzahl der Elemente, um den Durchschnitt zu erhalten.

func main() {
    a := make([]int, 100)
    for i := 0; i < len(a); i++ {
        a[i] = i
    }

    count := 10
    resultChan := make(chan int, count)
    chunkSize := len(a) / count

    for i := 0; i < count; i++ {
        startIndex := i * chunkSize
        endIndex := (i + 1) * chunkSize
        if i == count-1 {
            endIndex = len(a)
        }
        go sumChunk(a[startIndex:endIndex], resultChan)
    }

    total := 0
    for i := 0; i < count; i++ {
        total += <-resultChan
    }

    fmt.Println("Average value of array is: ", float32(total)/float32(len(a)))
}

func sumChunk(chunk []int, resultChan chan int) {
    sum := 0
    for _, v := range chunk {
        sum += v
    }
    resultChan <- sum
}

In diesem Beispiel definieren wir ein int-Typ-Array a mit einer Länge von 100. Für ein Array a der Länge len(a) erstellen wir count (hier 10) Goroutinen, um die Summe aller Elemente im Array a zu berechnen. Jede Goroutine berechnet die Summe einer Teilsequenz des Arrays a und sendet ihr Ergebnis an resultChan. Schließlich erhalten wir die Ergebnisse jeder Goroutine von resultChan und addieren sie, um die Summe aller Elemente zu erhalten und den Durchschnitt aller Elemente zu berechnen.

In der Praxis legen wir die Anzahl der Goroutinen normalerweise basierend auf den Rechenanforderungen fest. Wenn mehrere Kerne der CPU genutzt werden können, können wir die Anzahl der Goroutinen auf die Anzahl der CPU-Kerne einstellen. Andernfalls müssen wir die Anzahl der Goroutinen nach Bedarf festlegen, um die CPU-Ressourcen sinnvoll zu nutzen. Wenn zu viele Goroutinen vorhanden sind, kann es zu Problemen wie dem Kontextwechsel im System kommen, was zu Leistungseinbußen führt.

Das obige ist der detaillierte Inhalt vonParallelitätsimplementierung in der Golang-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!