Golang-Coroutinen und Parallelitätsmodell

Coroutinen in Go sind ein leichter Parallelitätsmechanismus, der die Ausführung mehrerer Aufgaben im selben Prozess ermöglicht. Sie teilen sich den Prozessspeicherplatz und können über Kanäle kommunizieren. Darüber hinaus bietet der Artikel Folgendes: Coroutine-Erstellung mit dem Schlüsselwort „go“. Kanäle werden mit der Make-Funktion erstellt und können zum Übergeben von Werten zwischen Coroutinen verwendet werden. Der praktische Fall zeigt, wie man Coroutinen verwendet, um paralleles Rechnen zu implementieren und 100.000 Primzahlen mithilfe von 8 Coroutinen zu berechnen.

Go-Coroutinen und Parallelitätsmodell

Einführung

Coroutinen sind ein leichter Parallelitätsmechanismus in der Go-Sprache, der die Ausführung mehrerer unabhängiger Aufgaben im selben Prozess ermöglicht. In diesem Artikel werden Coroutinen und Parallelitätsmodelle in Go untersucht und praktische Beispiele bereitgestellt.

Coroutinen

Coroutinen sind gleichzeitige Ausführungseinheiten in der Go-Sprache, ähnlich wie Threads, aber leichter. Coroutinen teilen sich den Speicherplatz desselben Prozesses und können problemlos Daten austauschen. Erstellen Sie Coroutinen mit dem Schlüsselwort go wie folgt:

go func() {
    // 协程体
}

Channels

Channels sind ein Kommunikationsmechanismus in Go, der zum Übergeben von Werten zwischen Coroutinen verwendet wird. Kanäle können unidirektional oder bidirektional sein und können gepuffert oder ungepuffert sein. Erstellen Sie einen Kanal mit der Make-Funktion, wie unten gezeigt:

ch := make(chan int, 10)

Übungsfall: Paralleles Rechnen

Lassen Sie uns Coroutinen verwenden, um einen praktischen Fall des parallelen Rechnens zu implementieren. Wir erstellen einen Pool von Coroutinen und berechnen in jeder Coroutine eine große Tabelle mit Primzahlen:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

const primeCount = 100000

// 计算素数
func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

// 协程函数
func parallelPrimes(ch chan int) {
    for i := 0; i < primeCount; i++ {
        n := rand.Intn(100000)
        if isPrime(n) {
            ch <- n
        }
    }
}

func main() {
    // 创建通道和协程池
    ch := make(chan int, primeCount)
    for i := 0; i < 8; i++ {
        go parallelPrimes(ch)
    }

    // 等待协程池完成
    close(ch)

    start := time.Now()
    // 收集素数
    for prime := range ch {
        fmt.Println(prime)
    }
    elapsed := time.Since(start)
    fmt.Printf("Elapsed time: %v\n", elapsed)
}

In diesem Fall haben wir 8 Coroutinen erstellt, von denen jede für die Berechnung von 100.000 Primzahlen verantwortlich ist. Die Haupt-Coroutine ist dafür verantwortlich, Primzahlen zu sammeln und sie auf der Konsole auszugeben.

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