一、先别急着带节奏,我们来看回调怎么回事
自己家里装了个智能门铃:有人按门铃,手机先响,你看到门口的人,才决定开门还是不开门。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 注意事项
- 回调接口一定要返回 SRS 能识别的格式。SRS 约定 HTTP 状态码 200 且响应体为 “0” 时表示成功,其他情况可能被判定为失败并触发重试。
- SRS 可能对同一个事件发送多次回调,所以业务接口必须做好幂等。可以用 stream 加 action 加时间戳做去重。
- 内存队列不适合关键任务。如果回调非常重要,建议使用 Redis Stream、RabbitMQ 或 Kafka 这类可以持久化的队列。
- 接口要设置超时,不能无限等下游。
- 必须记录日志。每一笔回调的请求来源、事件内容、耗时和返回结果都要留痕,否则故障时就像在黑灯里找东西。
- 上线前一定要压测,而且压测环境要和生产环境接近,否则数据参考价值不大。
六、总结和故障应急思路
遇到回调响应延迟过高,别急着拍脑袋改代码。先按这个顺序排查:
- 看 SRS 日志和回调服务访问日志,搞清楚到底是 SRS 发晚了,还是后端响应慢了。
- 用 Go 自带的 pprof 看回调服务的 CPU、内存和 goroutine 变化。
- 检查数据库慢查询和连接池是否打满。
- 看 SRS 是否因为超时在疯狂重试,导致回调服务被一群重复请求压垮。
- 确认当前改动是同步还是异步,别把鉴权逻辑改成异步放行。
回调响应快不等于业务必须马上完成。把不需要 SRS 等待的操作丢到后面慢慢做,是解决问题的根本思路。但也要记住,快不能以牺牲安全为代价。该鉴权的时候要等结果,该通知的时候才异步,这样既能保住用户体验,也能守住业务底线。
优化不是一次性的工作。今天改完连接池,明天可能又会冒出新的瓶颈。每次改动之后都用数据说话,把延迟压下去,把系统跑稳,才是真正解决问题的方式。
评论
围绕“SRS HTTP回调接口响应延迟过高的性能优化与故障解决”参与讨论