So verwenden Sie Goroutinen in der Go-Sprache für Web-Crawling mit hoher Parallelität

So verwenden Sie Goroutinen in der Go-Sprache für Web-Crawling mit hoher Parallelität.

Einführung:
Mit der kontinuierlichen Entwicklung des Internets wird die Crawler-Technologie in Bereichen wie Big Data und künstlicher Intelligenz häufig eingesetzt. Als effiziente, zuverlässige und von Natur aus Parallelität unterstützende Sprache eignet sich die Go-Sprache sehr gut für die Implementierung von Webcrawlern mit hoher Parallelität. In diesem Artikel wird erläutert, wie Sie mithilfe der Goroutines-Funktion der Go-Sprache einen einfachen, aber effizienten Webcrawler erstellen.

1. Was ist Goroutine? Zunächst müssen wir das Konzept von Goroutine verstehen. Goroutine ist eines der Kernkonzepte der gleichzeitigen Programmierung in der Go-Sprache und kann als leichter Thread oder Coroutine verstanden werden. Goroutinen können in einem separaten Thread ausgeführt und vom Laufzeitplaner der Go-Sprache verwaltet und geplant werden. Im Vergleich zu herkömmlichen Thread- und Coroutine-Modellen weist Goroutine einen geringeren Speicheraufwand und eine höhere Ausführungsleistung auf.

2. Grundprinzipien von Crawlern

Bevor wir einen Webcrawler implementieren, müssen wir zunächst die Grundprinzipien des Crawlers verstehen. Ein grundlegender Crawler-Prozess umfasst die folgenden Schritte:

Angeben der zu crawlenden URL;
1. Senden einer HTTP-Anfrage basierend auf der URL und Abrufen des zurückgegebenen HTML-Inhalts;
2. Parsen des HTML-Inhalts und Extrahieren der erforderlichen Daten; Fahren Sie mit dem nächsten Link fort und wiederholen Sie den obigen Vorgang.
4. 3. Verwenden Sie Goroutine, um einen Crawler mit hoher Parallelität zu implementieren.
Als Nächstes beginnen wir mit der Verwendung von Goroutine, um einen Webcrawler mit hoher Parallelität zu implementieren. Zuerst müssen wir einige Standardbibliotheken der Go-Sprache und Bibliotheken von Drittanbietern importieren.

package main

import (
    "fmt"
    "net/http"
    "io/ioutil"
    "regexp"
    "sync"
)

func main() {
    // 爬虫入口地址
    url := "https://example.com"

    // 创建一个 WaitGroup，用于等待所有 Goroutine 完成
    var wg sync.WaitGroup
    // 创建一个无缓冲的管道，用于传递需要爬取的网址
    urls := make(chan string)

    // 启动一个 Goroutine 用于传入入口地址
    wg.Add(1)
    go func() {
        urls <- url
        }()
    
    // 启动一个 Goroutine 用于爬取网址内容
    go func() {
        for url := range urls {
            // 发送 HTTP 请求
            resp, err := http.Get(url)
            if err != nil {
                fmt.Println("Error:", err)
                continue
            }

            // 读取响应内容
            body, err := ioutil.ReadAll(resp.Body)
            resp.Body.Close()
            if err != nil {
                fmt.Println("Error:", err)
                continue
            }

            // 提取网址中的链接，添加到管道中
            re := regexp.MustCompile(`<a[^>]+href=["'](https?://[^"']+)["']`)
            matches := re.FindAllStringSubmatch(string(body), -1)
            for _, match := range matches {
                go func(u string) {
                    urls <- u
                }(match[1])
            }
        }
        // 告诉 WaitGroup 这个 Goroutine 的工作已经完成
        wg.Done()
    }()

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

Im obigen Code erstellen wir zunächst eine WaitGroup-WG und eine ungepufferte Pipeline-URL. Anschließend wird in der Haupt-Goroutine zunächst die Crawler-Eintragsadresse an die Pipeline gesendet und dann eine Goroutine gestartet, um den Webinhalt zu crawlen. In dieser Goroutine verwenden wir eine HTTP-GET-Anfrage, um den Inhalt der Webseite abzurufen, verwenden reguläre Ausdrücke, um die Links in der Webseite zu extrahieren, und fügen die Links der Pipeline hinzu. Schließlich verwenden wir wg.Wait(), um zu warten, bis alle Goroutinen abgeschlossen sind.

Fazit:

Durch die Verwendung von Goroutine können wir Webcrawler mit hoher Parallelität problemlos in der Go-Sprache implementieren. Die leichte und effiziente Leistung von Goroutine ermöglicht es uns, mehrere Webseiten gleichzeitig zu crawlen und Links in Links rekursiv zu crawlen, um schnell die benötigten Daten zu erhalten. Darüber hinaus macht die Unterstützung der Go-Sprache für Parallelität unser Crawler-Programm stabiler und zuverlässiger.

Referenzlink:

Go-Parallelprogrammierung, https://golang.google.cn/doc/efficient_go.html#concurrency

Go-Standardbibliothek, https://golang.google.cn/pkg/
1. Go Tutorial zu regulären Ausdrücken, https://learn.go.dev/regular-expressions

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Goroutinen in der Go-Sprache für Web-Crawling mit hoher Parallelität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!