如何在Golang中提升网络请求并发性能

在Golang中处理高并发网络请求时，合理利用语言特性和优化请求逻辑，能显著提升整体性能。下面先介绍核心优化方向，再结合代码示例说明具体实现。

核心优化方向

1. 合理控制goroutine数量

虽然Golang的goroutine轻量，但无限制创建会导致调度开销增大，甚至触发内存溢出。可以通过带缓冲的channel实现简单的goroutine池，控制并发数量。

package main

import (
	"fmt"
	"net/http"
	"sync"
	"time"
)

// 请求任务结构体
type RequestTask struct {
	Url string
}

func main() {
	// 待请求的URL列表
	urls := []string{
		"http://ipipp.com/api/test1",
		"http://ipipp.com/api/test2",
		"http://ipipp.com/api/test3",
		"http://ipipp.com/api/test4",
		"http://ipipp.com/api/test5",
	}
	// 控制最大并发数为3
	maxWorker := 3
	taskChan := make(chan RequestTask, len(urls))
	// 将任务放入通道
	for _, url := range urls {
		taskChan <- RequestTask{Url: url}
	}
	close(taskChan)

	var wg sync.WaitGroup
	// 启动工作goroutine
	for i := 0; i < maxWorker; i++ {
		wg.Add(1)
		go func(workerID int) {
			defer wg.Done()
			for task := range taskChan {
				// 执行网络请求
				resp, err := http.Get(task.Url)
				if err != nil {
					fmt.Printf("worker %d 请求 %s 失败: %v\n", workerID, task.Url, err)
					continue
				}
				fmt.Printf("worker %d 请求 %s 成功，状态码: %d\n", workerID, task.Url, resp.StatusCode)
				resp.Body.Close()
			}
		}(i)
	}
	wg.Wait()
	fmt.Println("所有请求处理完成")
}

2. 复用HTTP连接

默认的http.Client如果没有合理配置，每次请求可能会创建新的TCP连接，带来额外的握手开销。可以通过自定义Transport参数，开启连接复用，减少连接建立成本。

package main

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

func main() {
	// 自定义Transport配置
	transport := &http.Transport{
		// 最大空闲连接数
		MaxIdleConns:        100,
		// 每个主机的最大空闲连接数
		MaxIdleConnsPerHost: 10,
		// 空闲连接超时时间
		IdleConnTimeout:     90 * time.Second,
		// 拨号超时配置
		DialContext: (&net.Dialer{
			Timeout:   30 * time.Second,
			KeepAlive: 30 * time.Second,
		}).DialContext,
	}
	// 创建复用连接的客户端
	client := &http.Client{
		Transport: transport,
		Timeout:   10 * time.Second,
	}
	// 多次请求同一个主机，会复用连接
	for i := 0; i < 5; i++ {
		resp, err := client.Get("http://ipipp.com/api/test")
		if err != nil {
			fmt.Printf("第 %d 次请求失败: %v\n", i+1, err)
			continue
		}
		fmt.Printf("第 %d 次请求成功，状态码: %d\n", i+1, resp.StatusCode)
		resp.Body.Close()
	}
}

3. 使用sync.Pool复用临时对象

网络请求中频繁创建临时对象（如缓冲区、请求结构体）会增加GC压力，使用sync.Pool可以缓存临时对象，减少重复创建的开销。

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"sync"
)

// 缓冲区对象池
var bufferPool = sync.Pool{
	New: func() interface{} {
		return new(bytes.Buffer)
	},
}

func main() {
	client := &http.Client{}
	// 发送带请求体的POST请求
	for i := 0; i < 3; i++ {
		// 从池中获取缓冲区
		buf := bufferPool.Get().(*bytes.Buffer)
		buf.Reset()
		// 写入请求体
		buf.WriteString(`{"id":1,"name":"test"}`)
		resp, err := client.Post("http://ipipp.com/api/post", "application/json", buf)
		if err != nil {
			fmt.Printf("请求失败: %v\n", err)
			bufferPool.Put(buf)
			continue
		}
		// 读取响应
		body, _ := io.ReadAll(resp.Body)
		fmt.Printf("响应内容: %s\n", body)
		resp.Body.Close()
		// 将缓冲区放回池中
		bufferPool.Put(buf)
	}
}

4. 合理设置超时时间

网络请求如果不设置超时，可能会因为目标服务不可用导致goroutine长时间阻塞，占用资源。需要为请求设置合理的连接超时、读写超时，避免资源无效占用。

上面的自定义http.Client示例中已经设置了10秒的整体超时，也可以针对Transport的DialContext和ResponseHeaderTimeout等参数做更细粒度的超时控制。

性能对比参考

以下是不同优化策略下的性能表现参考（测试环境：4核8G服务器，1000次请求）：

注意事项

• 不要无限制创建goroutine，根据CPU核心数和业务场景设置合理的并发上限
• 生产环境中建议对请求做错误重试，但要避免重试风暴，可以结合指数退避策略
• 监控goroutine数量、连接数、请求耗时等指标，及时发现性能瓶颈
• 如果请求的是外部服务，需要遵守对方的速率限制，避免被封禁

Golang网络请求并发性能goroutinesync.WaitGroup修改时间：2026-06-05 22:46:08