Cara menggunakan Goroutines dalam bahasa Go untuk merangkak web serentak tinggi

Cara menggunakan Goroutines dalam bahasa Go untuk merangkak web serentak tinggi

Pengenalan:
Dengan perkembangan berterusan Internet, teknologi perangkak telah digunakan secara meluas dalam bidang seperti data besar dan kecerdasan buatan. Sebagai bahasa yang cekap, boleh dipercayai dan sememangnya menyokong konkurensi, bahasa Go sangat sesuai untuk melaksanakan perangkak web konkurensi tinggi. Artikel ini akan memperkenalkan cara menggunakan ciri Goroutines bagi bahasa Go untuk membina perangkak web yang ringkas tetapi cekap.

1. Apa itu Goroutine
Pertama sekali, kita perlu memahami konsep Goroutine. Goroutine ialah salah satu konsep teras pengaturcaraan serentak dalam bahasa Go dan boleh difahami sebagai benang ringan atau coroutine. Goroutines boleh dijalankan dalam urutan yang berasingan dan boleh diurus dan dijadualkan oleh penjadual masa jalan bahasa Go. Berbanding dengan model benang dan coroutine tradisional, Goroutine mempunyai overhed memori yang lebih kecil dan prestasi pelaksanaan yang lebih tinggi.

2. Prinsip asas perangkak
Sebelum melaksanakan perangkak web, kita perlu terlebih dahulu memahami prinsip perangkak asas. Proses perangkak asas termasuk langkah-langkah berikut:

1. Nyatakan URL yang hendak dirangkak
2. Hantar permintaan HTTP berdasarkan URL dan dapatkan kandungan HTML yang dikembalikan
3. Uraikan kandungan HTML dan ekstrak data yang diperlukan
4. ; Teruskan melintasi pautan seterusnya dan ulangi proses di atas.

3. Gunakan Goroutine untuk melaksanakan perangkak konkurensi tinggi
Seterusnya, kami mula menggunakan Goroutine untuk melaksanakan perangkak web konkurensi tinggi. Pertama, kita perlu mengimport beberapa perpustakaan standard bahasa Go dan perpustakaan pihak ketiga.

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

Dalam kod di atas, kami mula-mula membuat WaitGroup wg dan url paip yang tidak dibuffer. Kemudian, dalam Goroutine utama, alamat kemasukan perangkak mula-mula dihantar ke saluran paip, dan kemudian Goroutine mula merangkak kandungan web. Dalam Goroutine ini, kami menggunakan permintaan HTTP GET untuk mendapatkan kandungan halaman web, menggunakan ungkapan biasa untuk mengekstrak pautan dalam halaman web dan menambah pautan ke saluran paip. Akhir sekali, kami menggunakan wg.Wait() untuk menunggu semua Goroutine selesai.

Kesimpulan:
Dengan menggunakan Goroutine, kami boleh melaksanakan perangkak web berkonkurensi tinggi dengan mudah dalam bahasa Go. Prestasi Goroutine yang ringan dan cekap membolehkan kami merangkak berbilang halaman web secara serentak dan secara rekursif merangkak pautan dalam pautan untuk mendapatkan data yang kami perlukan dengan cepat. Selain itu, sokongan bahasa Go untuk concurrency juga menjadikan program perangkak kami lebih stabil dan boleh dipercayai.

Pautan rujukan:

1. Go concurrent programming, https://golang.google.cn/doc/effective_go.html#concurrency
2. Go standard library, https://golang.google.cn/pkg/
3. Go Tutorial ekspresi biasa, https://learn.go.dev/regular-expressions

Atas ialah kandungan terperinci Cara menggunakan Goroutines dalam bahasa Go untuk merangkak web serentak tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!