go 函数的异步编程范式涉及：goroutine：轻量级并发单元，允许并行代码编写。channel：用于 goroutine 之间通信的管道。context：包含操作信息的容器，用于取消、设置截止或传递错误。实战案例包括使用 go 函数并行执行 http 请求，并在指定时间限制内取消它们。

Go 函数的异步编程范式与应用

异步编程是现代应用程序开发的一种重要方法，它可以让程序在不阻塞主线程的情况下执行长时间或 I/O 密集型操作。Go 语言提供了强大的特性来支持异步编程，包括 goroutine、channel 和上下文。

Goroutine

Goroutine 是 Go 中的轻量级并发单元，类似于线程。与传统线程不同，goroutine 非常轻量级，在创建和管理方面开销很低。Goroutine 被调度到操作系统的线程中执行，允许开发者编写并发代码而无需担心线程管理的复杂性。

package main

import (
    "fmt"
    "time"
)

func main() {
    go func() {
        fmt.Println("Hello from goroutine")
    }()

    time.Sleep(1 * time.Second)
}

Channel

Channel 是用于在 goroutine 之间通信的管道。它可以存储特定类型的值，并且具有缓冲容量。发送操作会在通道缓冲区已满时阻塞，而接收操作会在缓冲区为空时阻塞。

立即学习“go语言免费学习笔记（深入）”；

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan string, 10) // 创建容量为 10 的缓冲通道

    go func() {
        ch <- "Hello from goroutine" // 将值发送到通道
    }()

    msg := <-ch // 从通道接收值
    fmt.Println(msg)

    time.Sleep(1 * time.Second)
}

Context

Context 是一个包含有关正在进行操作的信息的对象。它可以传递给 goroutine 以取消操作、设置截止日期或传播错误。

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
    defer cancel() // 在 main 函数返回时取消上下文

    go func() {
        for {
            select {
            case <-ctx.Done(): // 上下文已取消，停止循环
                fmt.Println("Context cancelled")
                return
            default:
                // 继续执行操作
            }
        }
    }()

    time.Sleep(2 * time.Second)
}

实战案例

以下是一个使用 Go 函数进行异步编程的实战案例：

并行执行 HTTP 请求

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // 创建一个上下文，并在 5 秒后取消它
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 创建一个信道来接收请求的结果
    results := make(chan *http.Response)

    // 并行执行 HTTP 请求
    for _, url := range []string{"http://example.com", "http://example.org"} {
        go func(url string) {
            req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
            if err != nil {
                results <- nil
                return
            }

            resp, err := http.DefaultClient.Do(req)
            if err != nil {
                results <- nil
                return
            }

            results <- resp
        }(url)
    }

    // 从信道接收结果
    for i := 0; i < len([]string{"http://example.com", "http://example.org"}); i++ {
        resp := <-results
        if resp != nil {
            io.Copy(os.Stdout, resp.Body)
        }
    }
}

在这个案例中，我们并行执行 HTTP 请求，并在指定时间内限制它们的执行。如果请求在给定的时间内没有完成，它将被取消。通过使用 Go 函数的异步编程特性，我们可以并行执行这些请求，同时避免阻塞主线程。