一、先别急着带节奏,我们来看回调怎么回事

自己家里装了个智能门铃:有人按门铃,手机先响,你看到门口的人,才决定开门还是不开门。SRS 的回调就类似于这个门铃逻辑。只不过门铃变成了 HTTP 请求,开门变成了“允许推流”或“允许拉流”。

SRS 在关键事件发生时,会向业务后端发起 HTTP POST 请求。比如用户点击“开始直播”,SRS 会先给业务后端发一条消息问:“这个推流地址有效吗?能让他播吗?” 业务后端处理完后返回给 SRS 一个值。整个过程用户可等着呢。如果这个 HTTP 请求来回要 2 秒,那主播就会在直播间看到黑屏或者一直转圈。观众也可能被挡在门外。

这种回调用得非常多:开播鉴权、录制完成后通知、断流通知、实时在线人数统计。在不同场景下,延迟的影响不同:

  • 鉴权场景:延迟直接影响开播速度,属于致命伤。
  • 录制完成通知:延迟会让后期处理和上线慢,观众等回放等得久。
  • 统计类回调:延迟会让数据不正常,但用户往往无感知。

所以我们的优化目标很明确:让回调接口快速返回,同时不丢失关键业务逻辑。

二、延迟高的根源到底有哪些

2.1 业务代码在处理“重活”

最典型的慢,就是后端回调处理函数里既查数据库,又调用别人家的接口,还写日志,一圈下来几百毫秒没了。这几百毫秒是 SRS 发出回调请求之后,需要等待的时间。只要有几百路并发回调,接口很快就堵住了。

2.2 每个请求都重新建连接

很多人写 HTTP 客户端,随手 new 一个 client,发一次请求就完事。可每一次请求都要走一遍建连接的过程,也就是所谓的 TCP 握手,如果是 HTTPS 还有 TLS 握手。这部分消耗在高并发下甚至会超过业务处理本身的耗时。

2.3 没有超时保护

数据库查询慢,下游接口没响应,自己的回调接口也傻等。本来一个接口只要 20ms,结果因为一个下游无响应,整个请求卡了 20 秒。SRS 迟迟拿不到返回,又会触发重试,最后变成恶性循环。

2.4 部署和系统资源不到位

机器 CPU 不够用、内存不足、数据库连接池太小、容器网络受限,这些也都是延迟高的原因。但这类问题一般要等压测或者线上故障时才会暴露出来。

三、把 Go 回调服务做成“快枪手”

下面的示例代码统一使用 Go 语言。Go 做 HTTP 服务非常顺手,尤其适合这种需要高并发、低延迟的回调服务。

3.1 先写一个同步处理的“反面教材”

我们模拟一个回调接口。SRS 发送过来的请求体实际上是一个 JSON 数组,数组里每一个对象代表一个事件。这里我们只保留最关键的几个字段,方便理解。

package main

import (
	"encoding/json"
	"log"
	"net/http"
	"time"
)

// callbackEvent 对应 SRS 回调数组里的一个事件
type callbackEvent struct {
	Action string `json:"action"`
	Stream string `json:"stream"`
	IP     string `json:"ip"`
}

// callbackHandler 同步处理回调请求
func callbackHandler(w http.ResponseWriter, r *http.Request) {
	var events []callbackEvent
	if err := json.NewDecoder(r.Body).Decode(&events); err != nil {
		// 解析失败,返回非 0,SRS 会拒绝这次请求
		http.Error(w, "1", http.StatusBadRequest)
		return
	}

	// 遍历每个事件
	for _, ev := range events {
		// 模拟耗时业务:查数据库、调鉴权服务、写日志
		time.Sleep(200 * time.Millisecond)
		_ = ev
	}

	// SRS 看到返回 0,才会放行
	w.WriteHeader(http.StatusOK)
	_, _ = w.Write([]byte("0"))
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/callback", callbackHandler)

	srv := &http.Server{
		Addr:    ":8080",
		Handler: mux,
		// 这里没有设置超时,是隐患
	}

	log.Fatal(srv.ListenAndServe())
}

这个版本在本地跑,每个请求都要等 200ms。如果 SRS 每次推流都等这么久,主播心态很容易崩。

3.2 优化第一步:把业务处理本身变快

最直接的办法是减少同步处理的耗时。比如原来在回调里查数据库判断用户有没有权限,你可以先把权限数据放到 Redis 缓存里,用 key 直接查;也可以给数据库表加索引,把查询从几十毫秒压到几毫秒。这一步属于基础优化,不需要改接口结构,效果却非常明显。

3.3 优化第二步:使用 HTTP 连接池复用底层连接

如果回调服务需要主动请求第三方,请千万不要每个请求都创建一个新的 http.Client。在 Go 里,可以配置一个全局的 http.Client,让底层连接保持复用,避免重复握手。

// globalClient 全局复用同一个 HTTP 客户端
var globalClient = &http.Client{
	Timeout: 3 * time.Second, // 整个请求周期不能超过3秒
	Transport: &http.Transport{
		MaxIdleConns:        200, // 最多保留200个空闲连接
		MaxIdleConnsPerHost: 50,  // 每个目标主机最多复用50个空闲连接
		IdleConnTimeout:     90 * time.Second,
		TLSHandshakeTimeout: 3 * time.Second,
	},
}

连接池配置好之后,同一个目标主机的请求会尽量走已经建立的连接,而不是每次都从零开始。

3.4 优化第三步:不需要等结果的事情,放到后台异步处理

像开播统计、断流通知、录制完成通知这类不依赖返回结果的事件,完全没必要让 SRS 在那边傻等。我们可以先把任务丢进一个队列,然后立刻告诉 SRS“收到,返回 0”,真正的业务处理放到后台 worker 慢慢做。

需要注意:鉴权类回调不能这么做。因为 SRS 需要根据返回结果决定让不让人进来,你这里直接放行,坏人就也混进来了。

下面是一个完整的异步优化示例:

package main

import (
	"encoding/json"
	"log"
	"net/http"
	"time"
)

// callbackEvent 对应 SRS 回调事件
type callbackEvent struct {
	Action string `json:"action"`
	Stream string `json:"stream"`
	IP     string `json:"ip"`
}

// taskQueue 内存任务队列,用 channel 实现
var taskQueue = make(chan callbackEvent, 1000)

// worker 是后台消费任务的工人
func worker(id int) {
	for ev := range taskQueue {
		// 模拟真正的业务:读写数据库、调用统计系统等
		time.Sleep(50 * time.Millisecond)
		log.Printf("worker %d 处理: action=%s stream=%s", id, ev.Action, ev.Stream)
	}
}

// callbackHandler 接收 SRS 回调并快速返回
func callbackHandler(w http.ResponseWriter, r *http.Request) {
	var events []callbackEvent
	if err := json.NewDecoder(r.Body).Decode(&events); err != nil {
		http.Error(w, "1", http.StatusBadRequest)
		return
	}

	for _, ev := range events {
		select {
		case taskQueue <- ev:
			// 任务入队成功
		default:
			// 队列满了,说明后台处理不过来,先拒绝
			http.Error(w, "1", http.StatusServiceUnavailable)
			return
		}
	}

	// 先返回 0,SRS 不用等待业务完成
	w.WriteHeader(http.StatusOK)
	_, _ = w.Write([]byte("0"))
}

func main() {
	// 启动 8 个后台 worker 轮流处理任务
	for i := 0; i < 8; i++ {
		go worker(i)
	}

	srv := &http.Server{
		Addr:         ":8080",
		Handler:      http.HandlerFunc(callbackHandler),
		ReadTimeout:  3 * time.Second,
		WriteTimeout: 3 * time.Second,
		IdleTimeout:  60 * time.Second,
	}

	log.Fatal(srv.ListenAndServe())
}

这个版本把耗时操作从回调请求里挪走了。SRS 那边收到响应的时间通常会从几百毫秒下降到几毫秒。

3.5 优化第四步:限制并发,保护自己

回调接口可能一下子来几千个请求。如果每个请求都立刻处理,内存和 CPU 会被瞬间打满。我们可以用信号量控制同一时间同时处理的请求数,超过就快速返回失败,或者让调用方稍后重试。

// sem 是一个并发信号量,容量是 50
var sem = make(chan struct{}, 50)

func limitedHandler(w http.ResponseWriter, r *http.Request) {
	select {
	case sem <- struct{}{}:
		defer func() { <-sem }()
	case <-r.Context().Done():
		http.Error(w, "1", http.StatusRequestTimeout)
		return
	}

	// 后续正常的回调处理逻辑
}

这种方法对保护后端数据库非常有用。毕竟把请求挡在前面,总比让数据库被打挂要好。

四、压测一下,看看快了多少

4.1 写一个 Go 压测工具

为了不引入外部工具,我们可以直接用 Go 写一个小压测程序。它模拟 SRS 一次性发送 1000 个回调请求,并发 100,统计平均延迟。

package main

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

func main() {
	url := "http://127.0.0.1:8080/callback"
	body := []byte(`[{"action":"on_publish","stream":"test","ip":"1.2.3.4"}]`)

	totalRequests := 1000
	concurrency := 100

	var wg sync.WaitGroup
	sem := make(chan struct{}, concurrency) // 控制并发数量的信号量
	latencies := make([]time.Duration, totalRequests)

	start := time.Now()

	for i := 0; i < totalRequests; i++ {
		wg.Add(1)
		sem <- struct{}{}

		go func(index int) {
			defer wg.Done()
			defer func() { <-sem }()

			before := time.Now()
			resp, err := http.Post(url, "application/json", bytes.NewReader(body))
			if err == nil {
				// 关闭连接,释放资源
				_ = resp.Body.Close()
			}
			latencies[index] = time.Since(before)
		}(i)
	}

	wg.Wait()
	totalCost := time.Since(start)

	var sum time.Duration
	for _, d := range latencies {
		sum += d
	}
	avgCost := sum / time.Duration(totalRequests)

	fmt.Printf("总耗时: %v\n", totalCost)
	fmt.Printf("平均延迟: %v\n", avgCost)
}

运行这个工具,对比优化前后的平均延迟。通常优化前的接口可能平均 200ms 甚至更高,优化后同步接口能压到 20ms 以内,异步接口几乎等于一次本机网络转发的时间。

4.2 压测时要注意什么

压测不能只看平均值,建议再关注一下最大延迟和 P99 延迟。因为很多卡顿都来自长尾请求。如果 99% 的请求都在 10ms,最后 1% 却要 3 秒,那直播体验依然会出问题。可以把上面代码里每个延迟记录下来,排个序,看看 P99 是多少。

五、这套优化方案的优缺点和注意事项

5.1 技术优缺点

同步回调的优点在于逻辑简单、决策实时,SRS 拿到结果后马上知道能不能放行。缺点是任何一点慢都会被放大,尤其在回调里做了太多无关紧要的事。

异步回调的优点是把响应时间降下来了,系统吞吐量可以变得很高。缺点是需要考虑消息丢失、重复消费和服务重启时任务队列清空的问题。内存 channel 并不适合承载核心业务。

HTTP 连接池的优点是在高并发下减少握手开销,降低延迟。缺点是连接池参数如果调得太大,会占用很多文件描述符;调得太小,又起不到复用效果。

5.2 应用场景建议

  • 鉴权类回调:必须同步,不要异步。优化重点放在缓存、索引和减少依赖调用上,尽量让单次请求在 50ms 内返回。
  • 通知类回调:比如录制完成、断流通知,适合异步处理。先回 0,再在后台慢慢做,任务要保证幂等。
  • 统计类回调:比如在线人数、观看时长,允许少量丢失,可以大胆使用内存队列或更轻量的日志系统。

5.3 注意事项

  1. 回调接口一定要返回 SRS 能识别的格式。SRS 约定 HTTP 状态码 200 且响应体为 “0” 时表示成功,其他情况可能被判定为失败并触发重试。
  2. SRS 可能对同一个事件发送多次回调,所以业务接口必须做好幂等。可以用 stream 加 action 加时间戳做去重。
  3. 内存队列不适合关键任务。如果回调非常重要,建议使用 Redis Stream、RabbitMQ 或 Kafka 这类可以持久化的队列。
  4. 接口要设置超时,不能无限等下游。
  5. 必须记录日志。每一笔回调的请求来源、事件内容、耗时和返回结果都要留痕,否则故障时就像在黑灯里找东西。
  6. 上线前一定要压测,而且压测环境要和生产环境接近,否则数据参考价值不大。

六、总结和故障应急思路

遇到回调响应延迟过高,别急着拍脑袋改代码。先按这个顺序排查:

  1. 看 SRS 日志和回调服务访问日志,搞清楚到底是 SRS 发晚了,还是后端响应慢了。
  2. 用 Go 自带的 pprof 看回调服务的 CPU、内存和 goroutine 变化。
  3. 检查数据库慢查询和连接池是否打满。
  4. 看 SRS 是否因为超时在疯狂重试,导致回调服务被一群重复请求压垮。
  5. 确认当前改动是同步还是异步,别把鉴权逻辑改成异步放行。

回调响应快不等于业务必须马上完成。把不需要 SRS 等待的操作丢到后面慢慢做,是解决问题的根本思路。但也要记住,快不能以牺牲安全为代价。该鉴权的时候要等结果,该通知的时候才异步,这样既能保住用户体验,也能守住业务底线。

优化不是一次性的工作。今天改完连接池,明天可能又会冒出新的瓶颈。每次改动之后都用数据说话,把延迟压下去,把系统跑稳,才是真正解决问题的方式。