Golang implementiert Parallelität

Mit der kontinuierlichen Weiterentwicklung der Computertechnologie sind die Betriebseffizienz und Leistung moderner Programme zu immer wichtigeren Themen geworden. Die gleichzeitige Programmierung ist eine wichtige Möglichkeit, die Effizienz und Leistung der Programmausführung zu verbessern. Als aufstrebende Programmiersprache machen Golangs einzigartige Goroutine- und Kanalmechanismen die gleichzeitige Programmierung einfacher und effizienter.

In diesem Artikel werden die Grundkonzepte der gleichzeitigen Golang-Programmierung vorgestellt und anhand einiger Beispiele gezeigt, wie Goroutinen und Kanäle zum Erstellen effizienter gleichzeitiger Programme verwendet werden.

1. Was ist Goroutine? Goroutine ist ein leichter Thread in Golang. Die Größe jeder Goroutine beträgt nur etwa 2 KB und belegt nur sehr wenig Speicher und Ressourcen. Darüber hinaus weist der Golang-Scheduler Goroutinen automatisch verschiedenen physischen Threads zur Ausführung zu, wodurch eine gleichzeitige Ausführung erreicht wird.

Sie können eine Goroutine über das Schlüsselwort go starten, zum Beispiel:

package main

import (
    "fmt"
    "time"
)

func printNums() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    // 启动一个goroutine
    go printNums()

    // 继续执行主goroutine
    for i := 0; i < 5; i++ {
        fmt.Println("Hello")
        time.Sleep(time.Millisecond * 500)
    }
}

Führen Sie das obige Programm aus. Sie können sehen, dass die beiden Goroutinen abwechselnd Zahlen und Hallo ausgeben, wodurch eine gleichzeitige Ausführung erreicht wird.

2. Was ist ein Kanal? Ein Kanal in Golang ist eine Datenstruktur, die für die Kommunikation und Synchronisierung zwischen Goroutinen verwendet wird. Kanäle können Daten zwischen mehreren Goroutinen übertragen und über den Synchronisationsmechanismus des Kanals einen sicheren Datenaustausch erreichen. Es gibt zwei Arten von Kanälen: gepufferte und ungepufferte. Sende- und Empfangsvorgänge auf ungepufferten Kanälen blockieren, bis entsprechende Empfangs- und Sendevorgänge ausgeführt werden. Gepufferte Kanäle können den Zeitunterschied zwischen Sende- und Empfangsvorgängen bis zu einem gewissen Grad verringern.

Hier ist ein Beispiel für die Verwendung eines gepufferten Kanals:

package main

import (
    "fmt"
    "time"
)

func main() {
    // 创建一个大小为2的带缓冲通道
    ch := make(chan string, 2)

    // 启动两个goroutine
    go func() {
        ch <- "Hello"
        ch <- "World"
    }()
    go func() {
        time.Sleep(time.Second)
        fmt.Println(<-ch)
        fmt.Println(<-ch)
    }()

    // 等待goroutine执行完毕
    time.Sleep(time.Second * 2)
}

Im obigen Beispiel haben wir einen gepufferten Kanal der Größe 2 erstellt. Dann werden zwei Goroutinen gestartet, eine sendet zwei Strings an den Kanal und die andere empfängt die beiden Strings vom Kanal und gibt die Ausgabe aus. Aufgrund des Vorhandenseins des Puffers besteht ein gewisser Zeitunterschied zwischen den Sende- und Empfangsvorgängen, Daten können jedoch weiterhin über den Kanal übertragen und synchronisiert werden.

Neben gepufferten Kanälen unterstützt Golang auch ungepufferte Kanäle, wodurch die Synchronisation zwischen Goroutinen strenger gewährleistet werden kann.

3. Wie man Goroutine und Channel verwendet, um Parallelität zu erreichen

Durch die vorherige Einführung können wir sehen, dass Goroutine und Channel sehr nützliche Tools für die gleichzeitige Programmierung in Golang sind. Im Folgenden stellen wir einige Beispiele für deren Verwendung zur Implementierung der gleichzeitigen Programmierung vor.

1. Laden Sie mehrere Webseiten gleichzeitig herunter

Über Goroutine und Channel können wir problemlos mehrere Webseiten gleichzeitig herunterladen. Zum Beispiel:

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

// 下载网页的函数
func download(url string, ch chan<- string) {
    resp, err := http.Get(url)
    if err != nil {
        ch <- fmt.Sprintf("%s error: %v", url, err)
        return
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        ch <- fmt.Sprintf("%s error: %v", url, err)
        return
    }
    ch <- fmt.Sprintf("%s=%d", url, len(body))
}

func main() {
    // 要下载的网页列表
    urls := []string{
        "https://www.baidu.com",
        "https://www.google.com",
        "https://www.github.com",
    }

    // 创建一个无缓冲通道
    ch := make(chan string)

    // 启动多个goroutine下载网页
    for _, url := range urls {
        go download(url, ch)
    }

    // 从通道中读取结果，并打印输出
    for range urls {
        fmt.Println(<-ch)
    }

    // 等待goroutine执行完毕
    time.Sleep(time.Second * 2)
}

Im obigen Beispiel haben wir eine Download-Funktion definiert, um den Webseiteninhalt der angegebenen URL herunterzuladen und das Ergebnis über den Kanal zurückzugeben. Dann haben wir mehrere Goroutinen über die for-Schleife gestartet und jede Goroutine hat die Download-Funktion aufgerufen, um eine Webseite herunterzuladen. Nachdem das Download-Ergebnis über den Kanal zurückgegeben wurde, wird es in der Haupt-Goroutine gelesen und gedruckt. Auf diese Weise können wir problemlos mehrere Webseiten gleichzeitig herunterladen und die Betriebseffizienz und Leistung des Programms verbessern.

2. Mehrere Aufgaben gleichzeitig verarbeiten

Zusätzlich zum Herunterladen von Webseiten können wir auch Goroutine und Channel verwenden, um mehrere Aufgaben gleichzeitig zu verarbeiten. Zum Beispiel:

package main

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

func worker(id int, jobs <-chan int, results chan<- int) {
    for i := range jobs {
        fmt.Printf("worker %d start job %d
", id, i)
        time.Sleep(time.Duration(rand.Intn(3)) * time.Second)
        fmt.Printf("worker %d finish job %d
", id, i)
        results <- i * 2
    }
}

func main() {
    // 定义要处理的任务列表
    jobCount := 10
    jobs := make(chan int, jobCount)
    for i := 0; i < jobCount; i++ {
        jobs <- i
    }
    close(jobs)

    // 定义结果通道
    results := make(chan int, jobCount)

    // 启动多个goroutine处理任务
    workerCount := 3
    for i := 0; i < workerCount; i++ {
        go worker(i, jobs, results)
    }

    // 从结果通道中读取结果，并打印输出
    for j := 0; j < jobCount; j++ {
        fmt.Println(<-results)
    }

    // 等待goroutine执行完毕
    time.Sleep(time.Second * 2)
}

Im obigen Beispiel haben wir eine Worker-Funktion definiert, um die Verarbeitung der angegebenen Aufgabe zu simulieren. Dann haben wir mehrere Goroutinen über eine for-Schleife gestartet. Jede Goroutine hat eine Aufgabe aus dem Jobs-Kanal gelesen und verarbeitet. Die Verarbeitungsergebnisse werden über den Ergebniskanal zurückgegeben. Abschließend werden alle Ergebnisse aus dem Ergebniskanal in der Haupt-Goroutine gelesen und gedruckt. Auf diese Weise können wir problemlos mehrere Aufgaben gleichzeitig verarbeiten und die Laufeffizienz und Leistung des Programms verbessern.

4. Zusammenfassung

Dieser Artikel stellt die Grundkonzepte der gleichzeitigen Golang-Programmierung vor, einschließlich der Verwendung von Goroutine und Channel. Anhand mehrerer Beispiele zeigen wir, wie man Goroutinen und Kanäle nutzt, um effiziente gleichzeitige Programme zu erstellen. Im Vergleich zu anderen Programmiersprachen ist das gleichzeitige Programmiermodell von Golang prägnanter und effizienter, was die Effizienz und Leistung der Programmausführung erheblich verbessert. Es ist jedoch zu beachten, dass das Schreiben hochwertiger gleichzeitiger Programme nicht einfach ist. Es erfordert ein tiefgreifendes Verständnis und die Beherrschung der Mechanismen und Prinzipien der gleichzeitigen Golang-Programmierung.

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!