Go language core technology analysis

Concurrent programming in Go is implemented using goroutine (lightweight thread) and channel (communication pipe). Goroutine is created through the go keyword, which is very lightweight and can create a large number of goroutines without affecting performance. Channel is used for communication between goroutines and is a typed pipe. This example shows the application of concurrent crawlers, using goroutine to crawl URLs in parallel to improve efficiency.

Go core technology analysis: concurrent programming

The concurrency model in Go is based on goroutine (lightweight thread) and channel ( communication pipeline) concept. By taking full advantage of these features, developers can build highly concurrent, high-performance applications.

Goroutine

Goroutine is a lightweight thread in Go, created by the keyword go. They run on a coroutine scheduler, and unlike traditional threads, goroutines are very lightweight and thousands can be created without significant performance impact. The following code shows how to create and use a goroutine:

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 is a pipe used for communication between goroutines. They are typed, which means they can only pass values ​​of specific types. The following code shows how to create and use channels:

package main

import (
    "fmt"
)

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

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

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

Practical case: concurrent crawler

The following is a simplified example of using goroutine and channel to build a concurrent crawler:

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

By using goroutine and channel, this crawler can crawl multiple URLs concurrently, thus improving efficiency.

The above is the detailed content of Go language core technology analysis. For more information, please follow other related articles on the PHP Chinese website!