如何在Golang中实现异步网络请求

P粉602998670

发布时间：2025-10-04 14:51:02

637人浏览过

来源于php中文网

原创

答案：Golang通过goroutine和channel实现异步网络请求，配合http包高效并发；示例中并发获取多个URL内容，使用缓冲channel传递结果；为控制资源使用，可通过信号量限制goroutine数量；必须设置超时防止阻塞，推荐用带超时的http.Client和context控制请求生命周期；结合context可实现请求取消与截止时间管理，整体模型简洁高效。

如何在golang中实现异步网络请求

在Golang中实现异步网络请求，核心是利用 goroutine 和 channel 配合标准库中的 net/http 包。Go 的并发模型让发起多个网络请求变得简单高效，无需等待前一个请求完成。

使用 Goroutine 发起异步请求

每个 HTTP 请求可以在独立的 goroutine 中执行，这样不会阻塞主流程。通过 channel 将结果传回，避免竞态条件。

示例：并发获取多个 URL 内容

package main
import (
"fmt"
"io"
"net/http"
)
func fetchURL(url string, ch chan<- string) {
resp, err := http.Get(url)
if err != nil {
ch <- fmt.Sprintf("错误: %s -> %v", url, err)
return
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
ch <- fmt.Sprintf("成功: %s -> 长度 %d", url, len(body))

}
立即学习“go语言免费学习笔记（深入）”；
func main() {
urls := []string{
"https://www.php.cn/link/5f69e19efaba426d62faeab93c308f5c",
"https://www.php.cn/link/c2148796071914983ed6b6e9dbbff735",
"https://www.php.cn/link/1536687004241eb9faeee0e227b58c60",
}
ch := make(chan string, len(urls)) // 缓冲 channel

for _, url := range urls {
    go fetchURL(url, ch)
}

// 收集所有结果
for range urls {
    result := <-ch
    fmt.Println(result)
}
}
立即学习“go语言免费学习笔记（深入）”；
控制并发数量（限制 goroutine 数量）
如果请求太多，同时开启大量 goroutine 可能导致资源耗尽。可以用带缓冲的 channel 实现信号量机制来控制最大并发数。

							
								
								
									独响
									一个轻笔记+角色扮演的app
								
								下载 
							
						
func limitedFetch() {
    urls := [...]string{ /* 很多 URL */ }
    ch := make(chan string, len(urls))
    sem := make(chan struct{}, 10) // 最多 10 个并发
for _, url := range urls {
    sem <- struct{}{} // 占用一个槽
    go func(u string) {
        defer func() { <-sem }() // 释放
        resp, err := http.Get(u)
        if err != nil {
            ch <- fmt.Sprintf("失败: %s", u)
            return
        }
        ch <- fmt.Sprintf("成功: %s", u)
        resp.Body.Close()
    }(url)
}

// 等待全部完成
for i := 0; i < len(urls); i++ {
    fmt.Println(<-ch)
}

}
立即学习“go语言免费学习笔记（深入）”；
设置超时避免卡死
网络请求必须设置超时，否则可能无限等待。建议使用 http.Client 自定义超时时间。
client := &http.Client{
    Timeout: 5 * time.Second, // 整个请求超时
}
req, _ := http.NewRequest("GET", url, nil)
// 可选：为单个请求设置更细粒度的上下文超时
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req = req.WithContext(ctx)
resp, err := client.Do(req)

使用 Context 控制请求生命周期
当需要取消请求或传递截止时间时，context 是最佳选择。比如用户取消操作或服务关闭时，可以主动中断还在进行的请求。
ctx, cancel := context.WithCancel(context.Background())
// 在某个条件满足时调用 cancel()
req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
resp, err := http.DefaultClient.Do(req)

基本上就这些。Golang 的异步网络请求不依赖回调，而是通过 goroutine + channel + context 组合实现简洁高效的并发控制。只要注意超时、错误处理和资源释放，就能写出稳定可靠的网络代码。