Go 语言实现 API 请求队列处理限速与防 429

问题背景与解决思路

许多第三方接口提供严格的 QPS（每秒查询率）限制。当程序试图一次性发起多个请求时，后端通常会拒绝后续请求。传统的重试机制虽然能应对偶发限制，但无法从根本上避免阻塞。

核心思路是将所有待发出的 API 请求放入一个缓冲 Channel 中作为“队列”，并启动一个固定的工作协程（Goroutine）从队列中取出请求依次执行。这种生产者-消费者模式天然具备了流量整形的功能，确保同一时刻只有一个请求正在发出，从而规避了限流风控。

第1步：定义数据结构与队列容器

首先需要封装请求参数。每个请求应包含目标地址、HTTP 方法、请求体数据以及用于返回结果的 Channel。

在 Go 中，可以使用内置的 chan 类型来实现队列。下面是一个包含必要字段的结构体定义：

package util

import (
    apiclient "gitee.com/wangyubin/gutils/api_client"
    "gitee.com/wangyubin/gutils/logger"
)

// RequestParam 封装单个 API 的请求信息
type RequestParam struct {
	Api     string
	Method  string
	JsonReq interface{}
	Resp    chan []byte // 响应结果将通过此 channel 传回
}

// RequestQueue 请求队列实体
type RequestQueue struct {
	Queue chan RequestParam
}

var queue *RequestQueue

第2步：实现队列管理与初始化

为了统一管理实例，提供获取实例和初始化的辅助函数。初始化时需要指定队列容量，这决定了在未处理时的最大积压量。

// GetQueue 获取全局队列实例
func GetQueue() *RequestQueue {
	return queue
}

// InitRequestQueue 初始化队列，设置缓冲区大小 size
func InitRequestQueue(size int) {
	queue = &RequestQueue{
		Queue: make(chan RequestParam, size),
	}
}

第3步：编写消费逻辑 Run() 方法

这是核心的“去重”逻辑所在。通过读取 Channel 中的数据，并按顺序执行 HTTP 请求，然后将结果写入对应的 Resp Channel。

// Run 启动请求队列服务，持续消费队列中的任务
func (rq *RequestQueue) Run() {
	lg := logger.GetLogger()
	for p := range rq.Queue { // 遍历 Channel，直到关闭
		var resp []byte
		var err error
		// 根据 Method 选择 GET 或 POST
		switch p.Method {
		case "GET":
			resp, err = apiclient.GetJson(p.Api, p.JsonReq)
		case "POST":
			resp, err = apiclient.PostJson(p.Api, p.JsonReq)
		default:
			err = fmt.Errorf("Wrong type of METHOD(%s)", p.Method)
		}

		if err != nil {
			lg.Err(err).Msg("access api error: " + p.Api)
			continue // 发生错误跳过，避免阻塞整个队列
		}
		// 将响应结果放回到请求者的专属 Channel 中
		if p.Resp != nil {
			p.Resp <- resp
			close(p.Resp) // 关闭 channel 通知发送方结束等待
		}
	}
	lg.Info().Msg("request queue finished!")
}

性能调优提示：如果在上述流程中发现请求仍然过于频繁，可以在 Run() 函数的 for 循环开头加入固定时间的休眠（如 time.Sleep(100 * time.Millisecond)），以此人为增加请求间隔，满足更为苛刻的频率限制要求。

第4步：在业务代码中使用队列

使用时分为两步：先在入口点启动后台队列服务，再在业务逻辑中封装请求对象并送入队列。

1. 启动服务（通常在 main 函数中）：

func main() {
	// 初始化容量为 100 的队列
	util.InitRequestQueue(100)
	q := util.GetQueue()
	// 保证程序退出时清理资源
	defer close(q.Queue)
	
	// 在后台启动消费协程
	go q.Run()

	// 其他业务逻辑...
}

2. 调用 API：

func RequestData(param1 string, param2 int) error {
	q := util.GetQueue()
	
	// 构造 URL
	api := fmt.Sprintf("http://example.com?period=%s&size=%d", param1, param2)

	// 准备入队参数
	param := util.RequestParam{
		Api:    api,
		Method: "GET",
		Resp:   make(chan []byte, 1), // 创建接收结果的 Channel
	}

	// 将任务放入队列（如果满了此处会阻塞）
	q.Enqueue(param)

	// 解析响应
	var respData struct {
		Status string `json:"status"`
		Data   []struct{} `json:"data"`
	}

	// 阻塞等待结果
	for res := range param.Resp {
		if err := json.Unmarshal(res, &respData); err != nil {
			return err
		}
	}

	fmt.Println(respData)
	return nil
}

总结

利用 Go 语言自带的并发原语，可以极简地实现 API 请求队列。这种方法以牺牲微小的吞吐量为代价，换取了极高的稳定性与合规性，完美解决了 HTTP 429 报错痛点。以上就是 Golang API 请求队列的实现详细内容，更多关于 Go 网络编程优化的资料请关注本站其它相关文章！