Aller à l'analyse des technologies de base du langage

La programmation simultanée dans Go est implémentée à l'aide de goroutine (thread léger) et de canal (canal de communication). Goroutine est créé via le mot-clé go, qui est très léger et peut créer un grand nombre de goroutines sans affecter les performances. Le canal est utilisé pour la communication entre les goroutines et est un canal typé. Cet exemple montre l'application de robots d'exploration simultanés, utilisant goroutine pour explorer les URL en parallèle afin d'améliorer l'efficacité.

Analyse technologique de base de Go : programmation simultanée

Le modèle de concurrence dans Go est basé sur les concepts de goroutine (thread léger) et de canal (canal de communication). En tirant pleinement parti de ces fonctionnalités, les développeurs peuvent créer des applications hautement concurrentes et hautes performances.

Goroutine

Goroutine est un fil de discussion léger en Go, créé avec le mot-clé go. Ils fonctionnent sur un planificateur de coroutines et contrairement aux threads traditionnels, les goroutines sont très légères et des milliers peuvent être créées sans impact significatif sur les performances. Le code suivant montre comment créer et utiliser des goroutines :

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 est un canal utilisé pour la communication entre les goroutines. Ils sont typés, ce qui signifie qu'ils ne peuvent transmettre que des valeurs d'un type spécifique. Le code suivant montre comment créer et utiliser un canal :

package main

import (
    "fmt"
)

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

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

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

Cas pratique : Robot d'exploration simultané

Ce qui suit est un exemple simplifié d'utilisation de goroutine et de canal pour créer un robot d'exploration simultané :

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

En utilisant goroutine et canal, ce robot peut explorer simultanément Récupérer plusieurs URL, améliorant ainsi l'efficacité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!