Gehen Sie zur Analyse der Kerntechnologie der Sprache

Die gleichzeitige Programmierung in Go wird mithilfe von Goroutine (Lightweight Thread) und Channel (Kommunikationspipe) implementiert. Goroutine wird über das Schlüsselwort go erstellt, das sehr leichtgewichtig ist und eine große Anzahl von Goroutinen erstellen kann, ohne die Leistung zu beeinträchtigen. Der Kanal wird für die Kommunikation zwischen Goroutinen verwendet und ist eine typisierte Pipe. Dieses Beispiel zeigt die Anwendung gleichzeitiger Crawler, bei denen Goroutine zum parallelen Crawlen von URLs verwendet wird, um die Effizienz zu verbessern.

Go-Kerntechnologieanalyse: Gleichzeitige Programmierung

Das Parallelitätsmodell in Go basiert auf den Konzepten von Goroutine (leichter Thread) und Kanal (Kommunikationspipe). Durch die vollständige Nutzung dieser Funktionen können Entwickler hochgradig gleichzeitige Hochleistungsanwendungen erstellen.

Goroutine

Goroutine ist ein leichter Thread in Go, der mit dem Schlüsselwort go erstellt wurde. Sie laufen auf einem Coroutine-Scheduler, und im Gegensatz zu herkömmlichen Threads sind Goroutinen sehr leichtgewichtig und können ohne nennenswerte Leistungseinbußen zu Tausenden erstellt werden. Der folgende Code zeigt, wie man Goroutinen erstellt und verwendet:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Printf("Number of goroutines: %d\n", runtime.NumGoroutine()) // 当前正在运行的 goroutine 数量

    // 创建一个 goroutine
    go func() {
        fmt.Println("Hello from a goroutine!")
    }()

    fmt.Printf("Number of goroutines: %d\n", runtime.NumGoroutine()) // 当前正在运行的 goroutine 数量
}

Channel

Channel ist eine Pipe, die für die Kommunikation zwischen Goroutinen verwendet wird. Sie sind typisiert, was bedeutet, dass sie nur Werte bestimmter Typen übergeben können. Der folgende Code zeigt, wie ein Kanal erstellt und verwendet wird:

package main

import (
    "fmt"
)

func main() {
    // 创建一个 int 类型的 channel
    c := make(chan int)

    // 向 channel 发送值
    go func() {
        c <- 42
    }()

    // 从 channel 接收值
    v := <-c
    fmt.Println(v) // 输出：42
}

Praktischer Fall: Gleichzeitiger Crawler

Das Folgende ist ein vereinfachtes Beispiel für den Aufbau eines gleichzeitigen Crawlers mithilfe von Goroutine und Channel:

package main

import (
    "fmt"
    "net/http"
    "sync"
)

var wg sync.WaitGroup

func main() {
    // 要爬取的 URL 列表
    urls := []string{
        "https://example.com",
        "https://example2.com",
        "https://example3.com",
    }

    // 创建 channel 来接收每个 URL 的响应
    results := make(chan string)

    // 为每个 URL 创建一个 goroutine
    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            resp, err := http.Get(url)
            if err != nil {
                fmt.Printf("Error fetching %s: %v\n", url, err)
            } else if resp.StatusCode == 200 {
                results <- url
            }
            wg.Done()
        }(url)
    }

    // 从 channel 中获取响应
    go func() {
        for url := range results {
            fmt.Println(url)
        }
    }()

    // 等待所有 goroutine 完成
    wg.Wait()
}

Durch die Verwendung von Goroutine und Channel wird dies erreicht Der Crawler kann mehrere URLs gleichzeitig crawlen und so die Effizienz verbessern.

Das obige ist der detaillierte Inhalt vonGehen Sie zur Analyse der Kerntechnologie der Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!