Golang implementiert Parallelität

Mit der rasanten Entwicklung von Big Data, künstlicher Intelligenz und anderen Technologien wird auch die Nachfrage nach hoher Leistung und hoher Parallelität immer höher. In diesem Zusammenhang erfreut sich Golang als Programmiersprache mit hoher Parallelität und hoher Leistung großer Beliebtheit. Unter diesen ist die parallele Funktion von Golang eines der wichtigen Merkmale, die es von anderen Sprachen unterscheidet. In diesem Artikel wird hauptsächlich erläutert, wie Parallelität in Golang implementiert wird und welche Leistungsverbesserungen durch Parallelität erzielt werden.

1. Überblick über Parallelität

Parallel bezieht sich auf die gleichzeitige Ausführung mehrerer Aufgaben. Auf einer einzelnen CPU kann jeweils nur eine Anweisung ausgeführt werden, die Ausführungszeit jeder Anweisung ist jedoch sehr kurz. Aus Sicht des Benutzers führt die CPU Multitasking durch schnelle Rotation aus. Durch diese schnelle Rotation wird die Zeit für den Aufgabenwechsel sehr kurz und es sieht so aus, als würden mehrere Aufgaben gleichzeitig ausgeführt. Dies ist Parallelität.

In praktischen Anwendungen verwenden wir normalerweise parallele Technologie, um diese Geschäftsszenarien mit hoher Parallelität und hoher Dichte zu bewältigen. Durch Ausnutzung der Eigenschaften von Multi-Core-CPUs werden Aufgaben mehreren Kernen gleichzeitig zugewiesen Ausführung, Verbesserung der Ausführungseffizienz. In Golang wird Goroutine als leichter Thread bezeichnet. Er ist leichter und effizienter als ein Thread, und das Starten einer Goroutine erfordert nur sehr wenig Aufwand. Daher eignet sich Golang natürlich für die Implementierung paralleler Operationen.

2. Goroutine-Parallelität

In Golang können wir parallele Operationen durch Goroutine implementieren. Goroutine ist ein leichter Thread, der vom Golang-Laufzeitsystem verwaltet wird und im Gegensatz zu Betriebssystem-Threads nicht viel Speicher verbraucht. Daher können wir viele Goroutinen gleichzeitig starten, die Wartezeit von Aufgaben verkürzen und die Programmausführung verbessern. Effizienz. Werfen wir einen Blick darauf, wie man Goroutine startet.

1. Goroutine definieren

Sie müssen nur das Schlüsselwort go vor dem Funktionskörper hinzufügen, der unabhängig ausgeführt werden muss. Zum Beispiel:

go func() {
    fmt.Println("Hello, goroutine!")
}()

2. Goroutine starten

Goroutine starten ist sehr einfach, rufen Sie einfach die Funktion auf. Zum Beispiel:

func main() {
    go func() {
        fmt.Println("Hello, goroutine!")
    }()
    fmt.Println("Hello, main!")
    time.Sleep(time.Second)
}

Im obigen Code starten wir eine Goroutine, um einen Satz zu drucken, während die Hauptfunktion weiterhin ihre eigenen Wörter druckt und eine Sekunde lang pausiert. Wenn wir das Programm zu diesem Zeitpunkt ausführen, werden wir sehen, dass die Hauptfunktion und die Goroutine abwechselnd „Hallo, Haupt!“ und „Hallo, Goroutine!“ ausgeben, was beweist, dass die beiden Funktionen in verschiedenen Goroutinen parallel ausgeführt werden.

3. Kanal

Kanal ist ein von Golang bereitgestellter Inter-Thread-Kommunikationsmechanismus. Seine Funktion besteht darin, Daten zwischen Goroutinen zu übertragen. Ein Kanal hat zwei Endpunkte, das Sende- und das Empfangsende. Mit dem Schlüsselwort make können wir einen Kanal erstellen und dann mit <- Daten übertragen. Zum Beispiel: make来创建一个通道，然后利用<-来进行数据的传递。例如：

func goroutineFunc(c chan int) {
    c <- 1
}

func main() {
    c := make(chan int)
    go goroutineFunc(c)
    result := <-c
    fmt.Println(result)
}

上面的代码中，我们在启动goroutine的同时也创建了一个通道c，然后在goroutine中用c <- 1向通道中写入1，最后通过result := <-c

func pi(n int) float64 {
    ch := make(chan float64)
    for i := 0; i < n; i++ {
        go func(start, end int) {
            sum := 0.0
            for j := start; j < end; j++ {
                x := (float64(j) + 0.5) / float64(n)
                sum += 4.0 / (1.0 + x*x)
            }
            ch <- sum
        }(i*n/n, (i+1)*n/n)
    }
    result := 0.0
    for i := 0; i < n; i++ {
        result += <-ch
    }
    return result / float64(n)
}

func main() {
    fmt.Println(pi(10000))
}

Im obigen Code erstellen wir beim Starten der Goroutine auch einen Kanal c und verwenden dann c <- 1, um in den Kanal zu schreiben goroutine Geben Sie 1 ein und lesen Sie schließlich die Daten über result := <-c. Diese Methode kann Daten in verschiedenen Goroutinen austauschen und umfangreiche Paralleloperationen realisieren.

3. Paralleles Rechnen

Wenn wir paralleles Rechnen durchführen wollen, müssen wir Rechenaufgaben verschiedenen Goroutinen zur Ausführung zuweisen und Daten über Kanäle austauschen. Im Folgenden verwenden wir Beispielcode, um zu demonstrieren, wie Golang zur Implementierung paralleler Datenverarbeitung verwendet wird.

1. Parallele Berechnung des Pi-Werts

func MatrixMul(a, b [][]int) [][]int {
    m, n, p := len(a), len(a[0]), len(b[0])
    c := make([][]int, m)
    for i := 0; i < m; i++ {
        c[i] = make([]int, p)
    }

    ch := make(chan int)
    for i := 0; i < m; i++ {
        for j := 0; j < p; j++ {
            go func(x, y int) {
                sum := 0
                for k := 0; k < n; k++ {
                    sum += a[x][k] * b[k][y]
                }
                ch <- sum
            }(i, j)
        }
    }

    for i := 0; i < m; i++ {
        for j := 0; j < p; j++ {
            c[i][j] = <-ch
        }
    }

    return c
}

func main() {
    a := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
    b := [][]int{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
    fmt.Println(MatrixMul(a, b))
}

Im obigen Code erstellen wir zuerst einen Kanal ch mit einer Länge von n und verwenden dann n Goroutinen, um The zu berechnen Das Ergebnis wird in den Kanal geschrieben. Abschließend lesen wir die Summe aller Ergebnisse aus dem Kanal aus und berechnen den π-Wert. Durch paralleles Rechnen können wir die Berechnungsgeschwindigkeit erheblich steigern.

2. Parallele Berechnung der Matrixmultiplikation

rrreee

Im obigen Code verwenden wir Goroutine, um das Produkt von Matrizen parallel zu berechnen. Weisen Sie Goroutinen Rechenaufgaben zu und tauschen Sie dann Daten über Kanäle aus. Abschließend lesen wir alle Ergebnisse aus dem Kanal aus und bilden eine Produktmatrix. Durch paralleles Rechnen können wir die Rechengeschwindigkeit erhöhen und die Rechenkosten senken.

Zusammenfassung

In diesem Artikel wird hauptsächlich die Verwendung von Goroutine zur Implementierung paralleler Berechnungen in Golang sowie die Verwendung von Goroutine und Kanälen vorgestellt. Durch paralleles Rechnen können wir Rechenaufgaben mehreren Goroutinen zuweisen, um die Effizienz der Programmausführung zu verbessern, und sind für die Bewältigung von Geschäftsszenarien mit hoher Parallelität und hoher Dichte geeignet. Die integrierten Goroutine- und Kanalmechanismen von Golang machen Paralleloperationen einfacher und effizienter als andere Sprachen. #🎜🎜#

Das obige ist der detaillierte Inhalt vonGolang implementiert Parallelität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!