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))
}

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))
}

rrreee

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!