面试题集锦:Go 网络、netpoll 与协程池

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
netpoll / WebSocket
1. 概念定义
1.1 Hertz 网络模型
Hertz 是字节跳动开源的高性能 HTTP 框架,核心特性:
| 特性 | 说明 | Java 对应 |
|---|---|---|
| netpoll | 基于 epoll/kqueue 的 I/O 多路复用 | NIO Selector |
| goroutine per connection | 每个连接一个 goroutine | 线程池 |
| bitmask event | 事件触发机制 | SelectionKey |
1.2 netpoll 工作原理
┌─────────────────────────────────────────────────────────────┐
│ netpoll (epoll/kqueue) │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ Event Loop │ │
│ │ - 监听 fd 可读/可写事件 │ │
│ │ - 事件触发时调度对应 handler │ │
│ │ - 高效处理海量连接 │ │
│ └──────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Connection Pool │
│ - 管理 TCP 连接生命周期 │
│ - 复用连接减少建连开销 │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ Goroutine Pool │
│ - 请求处理goroutine复用 │
│ - 控制并发数量 │
└─────────────────────────────────────────────────────────────┘
2. 语法详解
2.1 Hertz Server 配置
import (
"github.com/cloudwego/hertz/pkg/app"
"github.com/cloudwego/hertz/pkg/app/server"
)
func main() {
h := server.New(
server.WithHostPorts(":8080"),
server.WithMaxRequestBodySize(4 * 1024 * 1024),
server.WithExitWaitTime(5 * time.Second),
)
h.GET("/health", func(c context.Context, ctx *app.RequestContext) {
ctx.JSON(200, map[string]string{"status": "ok"})
})
h.Spin()
}2.2 超时控制
// 读写超时配置
h := server.New(
server.WithHostPorts(":8080"),
// 读写超时设置为 3 秒
server.WithReadTimeout(3 * time.Second),
server.WithWriteTimeout(3 * time.Second),
// 最大连接空闲时间
server.WithIdleTimeout(30 * time.Second),
)3. 项目代码示例
3.1 WebSocket 处理器
项目中 WebSocket 实现(internal/api/handler/websocket/websocket.go):
package websocket
import (
"context"
"sync"
"time"
"github.com/gorilla/websocket"
"github.com/cloudwego/hertz/pkg/common/hlog"
)
const (
// 写超时
writeTimeout = 15 * time.Second
// 读超时(ping/pong 间隔)
readTimeout = 60 * time.Second
// 最大消息大小
maxMessageSize = 512
)
// Client WebSocket 客户端连接
type Client struct {
conn *websocket.Conn
hub *Hub
send chan []byte
userID string
mu sync.Mutex
}
// Hub 维护所有客户端连接
type Hub struct {
clients map[*Client]bool
broadcast chan []byte
register chan *Client
unregister chan *Client
mu sync.RWMutex
}
// NewHub 创建 Hub
func NewHub() *Hub {
return &Hub{
clients: make(map[*Client]bool),
broadcast: make(chan []byte, 256),
register: make(chan *Client),
unregister: make(chan *Client),
}
}
// Run 启动 Hub
func (h *Hub) Run(ctx context.Context) {
for {
select {
case <-ctx.Done():
h.closeAll()
return
case client := <-h.register:
h.mu.Lock()
h.clients[client] = true
h.mu.Unlock()
hlog.CtxInfof(ctx, "client registered: %s", client.userID)
case client := <-h.unregister:
h.mu.Lock()
if _, ok := h.clients[client]; ok {
delete(h.clients, client)
close(client.send)
}
h.mu.Unlock()
hlog.CtxInfof(ctx, "client unregistered: %s", client.userID)
case message := <-h.broadcast:
h.mu.RLock()
for client := range h.clients {
select {
case client.send <- message:
default:
close(client.send)
delete(h.clients, client)
}
}
h.mu.RUnlock()
}
}
}3.2 WebSocket 读写循环
// readPump 处理读取
func (c *Client) readPump(ctx context.Context) {
defer func() {
c.hub.unregister <- c
c.conn.Close()
}()
c.conn.SetReadLimit(maxMessageSize)
c.conn.SetReadDeadline(time.Now().Add(readTimeout))
c.conn.SetPongHandler(func(string) error {
c.conn.SetReadDeadline(time.Now().Add(readTimeout))
return nil
})
for {
_, message, err := c.conn.ReadMessage()
if err != nil {
if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseAbnormalClosure) {
hlog.CtxErrorf(ctx, "websocket read error: %v", err)
}
break
}
// 处理消息
c.handleMessage(ctx, message)
}
}
// writePump 处理写入
func (c *Client) writePump(ctx context.Context) {
ticker := time.NewTicker(pingInterval)
defer func() {
ticker.Stop()
c.conn.Close()
}()
for {
select {
case <-ctx.Done():
return
case message, ok := <-c.send:
c.conn.SetWriteDeadline(time.Now().Add(writeTimeout))
if !ok {
c.conn.WriteMessage(websocket.CloseMessage, []byte{})
return
}
c.mu.Lock()
err := c.conn.WriteMessage(websocket.TextMessage, message)
c.mu.Unlock()
if err != nil {
return
}
case <-ticker.C:
c.conn.SetWriteDeadline(time.Now().Add(writeTimeout))
if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
return
}
}
}
}3.3 消息类型定义
// MessageType 消息类型
type MessageType int
const (
MessageTypeText MessageType = iota
MessageTypeImage
MessageTypeAudio
MessageTypeSystem
)
// WSMessage WebSocket 消息结构
type WSMessage struct {
Type MessageType `json:"type"`
Content string `json:"content"`
From string `json:"from"`
To string `json:"to,omitempty"`
Timestamp int64 `json:"timestamp"`
}
// MarshalJSON 序列化消息
func (m *WSMessage) MarshalJSON() ([]byte, error) {
type Alias WSMessage
return json.Marshal(&struct {
*Alias
TypeStr string `json:"type_str"`
}{
Alias: (*Alias)(m),
TypeStr: messageTypeToString(m.Type),
})
}4. 业界应用案例
4.1 水滴筹实时消息
场景:捐款实时反馈 方案:WebSocket 推送捐款消息,支撑数百万并发连接 效果:捐款到账延迟 < 500ms
4.2 腾讯会议信令系统
场景:实时会议控制 方案:WebSocket 处理会议信令,控制频道切换 效果:信令延迟 < 50ms
4.3 钉钉消息推送
场景:企业消息实时推送 方案:Hertz + WebSocket 混合架构 效果:单机能支撑 10 万+ 并发连接
5. 业务场景对照
5.1 何时使用 WebSocket
| 场景 | 推荐方案 | 原因 |
|---|---|---|
| 实时聊天 | WebSocket | 双向实时通信 |
| 股票行情 | SSE/WebSocket | 实时性要求高 |
| 文件上传进度 | SSE | 单向推送即可 |
| 订单状态更新 | WebSocket | 实时双向 |
| 邮件推送 | 轮询/SSE | 实时性要求不高 |
5.2 注意事项
// 错误 1:不设置超时
func badHandler(conn *websocket.Conn) {
for {
_, _, err := conn.ReadMessage() // 没有超时,可能永久阻塞
if err != nil {
break
}
}
}
// 正确做法:设置读写超时
func goodHandler(conn *websocket.Conn) {
conn.SetReadLimit(maxMessageSize)
conn.SetReadDeadline(time.Now().Add(readTimeout))
conn.SetPongHandler(func(string) error {
conn.SetReadDeadline(time.Now().Add(readTimeout))
return nil
})
}
// 错误 2:goroutine 泄漏
func badConnection(conn *websocket.Conn) {
go func() {
for {
_, _, err := conn.ReadMessage() // 连接关闭后 goroutine 可能不退出
if err != nil {
return
}
}
}()
}
// 正确做法:使用 context 控制生命周期
func goodConnection(ctx context.Context, conn *websocket.Conn) {
go func() {
for {
select {
case <-ctx.Done():
return
default:
_, _, err := conn.ReadMessage()
if err != nil {
return
}
}
}
}()
}6. 常见问题与解答
Q13: WebSocket 代码走读?
答:WebSocket 使用 gorilla/websocket 库,主要包含:
Upgrader将 HTTP 连接升级为 WebSocketreadPump循环读取消息writePump循环发送消息,配合 ping/pong 保活Hub管理所有客户端连接
Q17: Hertz netpoll 模型?
答:Hertz 使用 netpoll(基于 epoll/kqueue)实现高性能 I/O:
- 非阻塞 I/O,避免阻塞等待
- 事件驱动,事件触发时调度 handler
- 配合 goroutine,实现高并发处理
7. 连接健康检查
7.1 WebSocket 心跳机制
const (
pingInterval = 30 * time.Second
pongTimeout = 60 * time.Second
)
func (c *Client) startHeartbeat(ctx context.Context) {
ticker := time.NewTicker(pingInterval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
c.mu.Lock()
c.conn.SetWriteDeadline(time.Now().Add(writeTimeout))
if err := c.conn.WriteMessage(websocket.PingMessage, nil); err != nil {
c.mu.Unlock()
hlog.CtxErrorf(ctx, "ping failed: %v", err)
return
}
c.mu.Unlock()
}
}
}7.2 连接状态监控
// ClientState 客户端状态
type ClientState int
const (
StateConnecting ClientState = iota
StateConnected
StateReconnecting
StateDisconnected
)
// Monitor 连接监控
func (h *Hub) Monitor() map[ClientState]int {
h.mu.RLock()
defer h.mu.RUnlock()
stats := make(map[ClientState]int)
for client := range h.clients {
stats[StateConnected]++
}
return stats
}ants 与并发模式
本文用贴近业务的例子说明常见并发原语,并介绍 ants v2 的用法、典型场景,以及与「原生 WaitGroup + channel / semaphore」的取舍。官方包文档见 pkg.go.dev/github.com/panjf2000/ants/v2。
目录
- Goroutine
- Channel
- 同步原语:WaitGroup、Mutex、Once
- 有界并发:带缓冲 channel 与 semaphore
- errgroup
- Context 与取消
- 贴近业务的组合示例
- ants v2 协程池
- ants 与原生实现对比与选型
- 参考链接
1. Goroutine
是什么: Go 里轻量线程,由 runtime 调度,适合 I/O 密集或可并行的独立任务。
现实场景: 批量调外部 HTTP、并发写库(注意连接池与事务边界)、为每个用户请求起一段独立逻辑(仍要限流,见下文)。
// 主 goroutine 不等待子协程时,程序可能直接退出
func main() {
done := make(chan struct{})
go func() {
// 模拟拉取一个订单详情
_ = fetchOrder("order-1")
close(done)
}()
<-done
}
func fetchOrder(id string) string { return id + ":ok" }注意:
go与调用方并发执行,要「等结果」用channel、WaitGroup或errgroup。- 闭包里循环变量要复制进闭包,避免经典 bug(Go 1.22+ 的
for range语义有调整,仍建议显式i := i以兼容老版本思维)。
2. Channel
是什么: goroutine 之间传值 + 同步的管道;未缓冲 = 同步握手,有缓冲 = 异步直到缓冲满。
2.1 无缓冲:必须两端同时准备好
像「递接力棒」:发送方和接收方必须同时在,适合严格一对一交接。
func main() {
ch := make(chan string)
go func() {
ch <- "result" // 会阻塞,直到有人接收
}()
fmt.Println(<-ch)
}2.2 有缓冲:异步排队
// 容量 2:送第三份前,前两个可暂存
q := make(chan int, 2)
q <- 1
q <- 2
fmt.Println(<-q, <-q)2.3 select:多路等待(超时、取消、多 channel)
现实场景: 等结果,但最多等 2 秒;或同时监听 ctx.Done()。
func doWithTimeout(result chan string) {
select {
case v := <-result:
fmt.Println(v)
case <-time.After(2 * time.Second):
fmt.Println("timeout")
}
}2.4 关闭与 for range
只应由发送方关闭;接收方用 for v := range ch 读到流结束。
func fanIn() {
out := make(chan int)
go func() {
defer close(out)
for i := 0; i < 3; i++ {
out <- i
}
}()
for v := range out {
fmt.Println(v)
}
}2.5 chan struct{} 作「只通知」
不占内存,常用来表示 done / ready。
done := make(chan struct{})
go func() { /* work */; close(done) }()
<-done3. 同步原语:WaitGroup、Mutex、Once
3.1 sync.WaitGroup:等一批 goroutine 跑完
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
// 并发任务 id
_ = id
}(i)
}
wg.Wait()3.2 sync.Mutex:保护共享写(map、slice、计数器)
var (
mu sync.Mutex
sum int
)
// 多个 goroutine 里:mu.Lock(); sum++; mu.Unlock()3.3 sync.Once:全局只执行一次(例如单例、一次初始化)
var once sync.Once
once.Do(func() { /* init */ })4. 有界并发:带缓冲 channel 与 semaphore
问题: 为每个任务 go 一个协程,任务成千上万时会拖垮调度与内存。需要同时最多 N 个在跑。
4.1 用带缓冲 channel 当「许可证」
// 最多 3 个任务同时执行(类似停车场 3 个车位)
const maxConcurrent = 3
tokens := make(chan struct{}, maxConcurrent)
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
tokens <- struct{}{} // 取令牌;满则阻塞
go func(id int) {
defer func() { <-tokens; wg.Done() }()
process(id)
}(i)
}
wg.Wait()语义: 与 x/sync/semaphore 的 Weighted 类似;N=1 时就是互斥执行的变体(通常直接用 Mutex 更简单)。
4.2 golang.org/x/sync/semaphore(可传 context、支持权重)
现实场景: 每个任务消耗不同资源时可用带权;常见仍是权重 1。
import "golang.org/x/sync/semaphore"
sem := semaphore.NewWeighted(4)
if err := sem.Acquire(ctx, 1); err != nil { /* ctx 取消 */ return }
defer sem.Release(1)
// ... 做 CreateChat、HTTP 等 ...Acquire(ctx,1) 在请求取消时会返回错误,比纯 channel 更适合链路透传 context 的服务端代码(例如你们 batch 建群 / 发消息 Handler)。
5. errgroup
包: golang.org/x/sync/errgroup
用途: 一组子任务,需要都跑完;常希望第一个非 nil 错误后取消兄弟任务的 Context。
g, ctx := errgroup.WithContext(ctx)
g.Go(func() error { return callA(ctx) })
g.Go(func() error { return callB(ctx) })
if err := g.Wait(); err != nil { /* 处理 */ }和「批量各自成功失败」不同: 你们的 batch 接口是每条独立成功/失败,更常用 WaitGroup + 预分配 results[i],不要因一条失败就 errgroup 全停(除非产品要求整批失败即停)。
6. Context 与取消
现实场景: 客户端断开、父请求超时、上游取消。
- 在
select里监听<-ctx.Done()。 - I/O 调用的
http.NewRequestWithContext、Mongo 等传ctx。 - 与
semaphore.Acquire(ctx,1)配合,取消时不要再占坑。
7. 贴近业务的组合示例
7.1 限流 + 保序写结果:批量 HTTP 拉取(类似 batch 多 URL)
需求: 100 个 URL,同时最多 5 个在请求,结果下标与入参一致。
func fetchAll(ctx context.Context, urls []string) []fetchResult {
n := len(urls)
out := make([]fetchResult, n)
sem := semaphore.NewWeighted(5)
var wg sync.WaitGroup
for i := range urls {
wg.Add(1)
go func(i int) {
defer wg.Done()
if err := sem.Acquire(ctx, 1); err != nil {
out[i] = fetchResult{Err: err}
return
}
defer sem.Release(1)
body, err := httpGet(ctx, urls[i])
out[i] = fetchResult{Body: body, Err: err}
}(i)
}
wg.Wait()
return out
}
// 示意类型
type fetchResult struct{ Body string; Err error }
func httpGet(ctx context.Context, url string) (string, error) {
// ...
return "", nil
}7.2 固定 N 个 worker 从 jobs 取(经典 worker pool)
需求: 任务在 jobs 里排队,永远只跑 workerN 个 goroutine(适合任务持续到达的生产者-消费者模型)。
func runPool(workerN int, jobs []int, process func(int)) {
jch := make(chan int)
var wg sync.WaitGroup
for w := 0; w < workerN; w++ {
wg.Add(1)
go func() {
defer wg.Done()
for j := range jch {
process(j)
}
}()
}
for _, j := range jobs {
jch <- j
}
close(jch)
wg.Wait()
}8. ants v2 协程池
一句话: 固定容量复用大量 goroutine 的池;限制并发数、回收/清理、可选 panic 不拖垮进程 等。官方说明:适合「大量创建又销毁的 goroutine」、高并发批处理、HTTP 下异步任务等。
安装:
go get -u github.com/panjf2000/ants/v2官方包文档(API 全量、Option、Error):
https://pkg.go.dev/github.com/panjf2000/ants/v2
8.1 包级默认池 + Submit(小工具、demo)
import "github.com/panjf2000/ants/v2"
func useDefault() {
_ = ants.Submit(func() { /* 任务 */ })
// 进程退出前建议 Release 默认池(长驻服务要留意)
}8.2 自建 Pool:容量确定时(与「最多 N 个同时跑」一致)
pool, err := ants.NewPool(10) // 最多 10 个 worker
if err != nil {
panic(err)
}
defer pool.Release()
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
i := i
wg.Add(1)
_ = pool.Submit(func() {
defer wg.Done()
_ = i
// 业务:调 DB、HTTP
})
}
wg.Wait()常用 Option(见 Options):
| Option | 含义(简述) |
|---|---|
ants.WithPreAlloc(true) | 预分配,大容量+长任务时可能减少分配开销 |
ants.WithNonblocking(true) | 满则 Submit 不阻塞,返回 ErrPoolOverload |
ants.WithMaxBlockingTasks(n) | 阻塞在 Submit 上的 goroutine 数上限(需细读与 Nonblocking 关系) |
ants.WithPanicHandler | 任务 panic 时集中处理,避免整进程挂 |
ants.WithExpiryDuration | 清理闲置过久的 worker 周期 |
运行时调大池子: pool.Tune(newSize)(注意文档:对 unlimited / 预分配池可能无效)。
释放:Release / ReleaseTimeout / ReleaseContext(ctx)(v2.12+ 的 context 版本适合「优雅退出前等 worker 结束」)。
8.3 PoolWithFunc / NewPoolWithFunc:所有任务共用一个处理函数
适合「任务只是参数不同」(例如 orderID int、URL 字符串),少写闭包分配。
var sum int32
var mu sync.Mutex
pool, _ := ants.NewPoolWithFunc(8, func(arg any) {
id := arg.(int)
_ = id
mu.Lock()
sum++
mu.Unlock()
})
defer pool.Release()
for i := 0; i < 100; i++ {
_ = pool.Invoke(i) // 交给池里统一 fn
}泛型版: ants.NewPoolWithFuncGeneric[int](8, func(id int) { ... })(v2.11+),类型安全,少 any 强转。
8.4 MultiPool:多子池 + 负载均衡,减轻单池大锁瓶颈
NewMultiPool:size 是子池个数,sizePerPool 是每个子池容量;RoundRobin 或 LeastTasks 分配任务。适合超大量 Submit 且池成为热点的场景。
// 示意:10 个子池、每个子池容量 runTimes/10、轮询分流
// mp, _ := ants.NewMultiPool(10, runTimes/10, ants.RoundRobin, opts...)
// defer mp.ReleaseTimeout(time.Second)
// mp.Submit(func() { ... })8.5 顺序不保证(与你们 batch 按 index 回写 的关系)
官方说明: 提交到池中的任务不会保证执行顺序;和「每个任务自己写 results[i]」不冲突——顺序由下标 i 保证,不是由执行先后保证。
实现 batch 时:Submit 闭包内仍写 results[ idx ],不要依赖「先跑完 0 再 1」。
8.6 与你们 Handler 中「semaphore + 每任务一个 go」的类比
- ants: 复用固定 worker 执行任意
func(),减少无界go的调度/栈开销。 - semaphore + N 个 go 同时跑: 常是「本次请求里最多 5 个并发」,请求结束就结束;不强调跨请求的 goroutine 复用。
- 若把 ants 当「全局长驻池」: 在 HTTP 入口 里反复
Submit大量短任务,ants 很合适;一次性 20 条批处理,**原生 WaitGroup+semaphore 往往更简单、依赖更少。见下一节。
9. ants 与原生实现对比与选型
| 维度 | 原生 WaitGroup + semaphore 或 chan struct{} + go | ants Pool / Submit |
|---|---|---|
| 依赖 | 仅标准库 + golang.org/x/sync | 多一个第三方,需升级、审计 |
| 心智 | 每个请求一批任务,与请求生命周期绑定 很直观 | 全局/长驻池,注意 Release、默认池生命周期 |
| 复用 | 每次 batch 新建 N 个并发单元(或固定 go 数由 sem 限) | 跨请求复用 worker,高 QPS 短任务有优势 |
| Context 取消 | sem.Acquire(ctx,1) 原生友好 | 任务内自行用传入的 ctx;Submit 不替你取消 |
| 顺序 | 用 results[i] 与原生相同 | 同样按 i 写结果,不依赖执行顺序 |
| panic | 要 recover 否则整个进程危险 | 可用 WithPanicHandler 统一兜底 |
| 调参 | 改一个 maxConcurrent 常数 | Tune、MultiPool、Option 多,调优空间大也更复杂 |
建议:
- 单接口内 20 条有界并发(如 batch 建群/发消息):
WaitGroup+semaphore+ 按下标写回,够清晰、好测。 - 全进程持续涌入海量小任务(如异步通知、流式转码任务投递):ants 或项目自研 worker 池(如本仓库 WORKER_POOL.md)更对口。
- 若已引入 ants 又希望风格统一,可把批处理改成「向池 Submit、闭包抓
i/arg」;注意pool.Release在进程/测试生命周期内只调一次,不要每个 HTTP 请求 new 一个池再 release(除非有明确设计)。
9.1 用 ants 写「同语义的 batch」示意(与 semaphore 版对照)
// 示意:仅表达结构;error 与 pool 错误需按业务补全
func batchWithAnts(ctx context.Context, n int, work func(int) error) []error {
pool, _ := ants.NewPool(4)
defer pool.Release()
errs := make([]error, n)
var emu sync.Mutex
var wg sync.WaitGroup
for i := 0; i < n; i++ {
i := i
wg.Add(1)
_ = pool.Submit(func() {
defer wg.Done()
err := work(i)
emu.Lock()
errs[i] = err
emu.Unlock()
})
}
wg.Wait()
return errs
}对比: semaphore 版是「控制并发」;ants 版还多了「worker 长期复用」。对只跑几十毫秒就结束的 HTTP 里的一次 batch,收益常不明显,却增加全局池的运维成本。
10. 参考链接
- The Go Memory Model — 并发下可见性必读本(官方)
- golang.org/x/sync/errgroup
- golang.org/x/sync/semaphore
- ants 仓库
- ants v2 包文档 (pkg.go.dev)
- 本仓库自研池设计(如适用):WORKER_POOL.md
文档为通用说明,与具体业务线模块版本无关;ants 具体 API 以 v2.12+ 的 pkg.go.dev 为准。
并发实践
结合项目实际代码讲解并发原语,帮助快速掌握并应用到具体业务场景。
目录
- errgroup - 并发子任务 + 错误传播与取消
- semaphore - 有界并发控制
- 缓冲 Channel - 生产者-消费者模式
- Worker Pool - 固定数量 Worker 消费任务队列
- sync.Once - 单次初始化
- sync.Mutex / RWMutex - 并发安全
- Context 取消传播
- 业务场景与并发特性对照表
- 你的代码中已有的优化模式
- 哪些场景可以考虑升级
1. errgroup - 并发子任务 + 错误传播与取消
特性说明
文档定义: 一组子任务需要都跑完,希望第一个非 nil 错误后取消所有兄弟任务的 Context。
核心语义:
errgroup.WithContext(ctx)创建的 group,任意一个g.Go()返回错误,会自动取消其他 goroutine 的 context- 适合「多个独立 API/数据库查询需要同时执行,任意一个失败就整体失败」的场景
项目中的实际应用
应用位置: internal/service/analytics/hierarchy_analytics.go:78
g, gctx := errgroup.WithContext(ctx)
g.Go(func() error {
n, err := s.brokerageRepo.CountAll(gctx)
totalBrokerages = n
return err // 如果失败,会取消其他 gctx 的任务
})
g.Go(func() error {
n, err := s.officeRepo.CountAll(gctx)
totalOffices = n
return err
})
g.Go(func() error {
n, err := s.agentRepo.CountAll(gctx)
totalAgencies = n
return err
})
g.Go(func() error {
n, err := s.publicListingRepo.CountAll(gctx)
totalListings = n
return err
})
if err := g.Wait(); err != nil {
return nil, err // 任一失败则整体失败
}业务场景
统计页面:同时查询 4 个独立数据源的总数(brokerages、offices、agents、listings),任意一个失败则请求失败,返回给前端「数据加载失败」而非「部分数据」。
适用场景
| 场景 | 说明 |
|---|---|
| 多个独立 API 调用 | 并行获取数据,一个失败则整体失败 |
| 多个独立数据库查询 | 减少总响应时间(串行 vs 并行) |
| 需要自动取消 | 第一个失败后,其他正在进行的查询可以被取消 |
| 熔断逻辑 | 一个服务不可用时快速失败 |
2. semaphore - 有界并发控制
特性说明
文档定义:
每个任务消耗不同资源时可用带权;Acquire(ctx,1) 在请求取消时会返回错误,比纯 channel 更适合链路透传 context 的服务端代码。
两种实现方式:
golang.org/x/sync/semaphore- 官方库,支持 context 取消和权重make(chan struct{}, n)- Channel 实现,语义相同
项目中的实际应用(channel-based)
应用位置 1: internal/service/chat/chat.go:1437-1461
const maxConcurrency = 10
semaphore := make(chan struct{}, maxConcurrency) // 信号量模式
var wg sync.WaitGroup
for _, chatID := range chatIDs {
wg.Add(1)
go func(cid primitive.ObjectID) {
defer wg.Done()
semaphore <- struct{}{} // 获取令牌,满则阻塞
defer func() { <-semaphore }()
// 执行实际任务
messages, err = s.messageRepo.GetTaggedMessagesAfterMessageID(ctx, cid, lastReadMessageID)
}(chatID)
}
wg.Wait() // 等待所有任务完成应用位置 2: internal/service/message/message.go:1937
const maxConcurrency = 50
sem := make(chan struct{}, maxConcurrency)
var wg sync.WaitGroup
for _, memberID := range chatMemberIDs {
wg.Add(1)
go func(uid string) {
defer wg.Done()
sem <- struct{}{} // 获取令牌
defer func() { <-sem }()
s.readCacheService.IncrChatUnreadCount(ctx, chatIDStr, uid)
}(memberIDStr)
}
wg.Wait()业务场景
聊天室更新非阅读计数:聊天室有 500 人,需要更新所有成员的非阅读消息数量。如果同时启动 500 个 goroutine 会耗尽系统资源。使用 semaphore 限制最多同时 50 个并发操作,剩余的排队等待。
适用场景
| 场景 | 说明 |
|---|---|
| 限制同时执行的任务数 | 数据库连接池限制、外部 API 限流 |
| 任务数量大但系统资源有限 | 批量更新大量用户的数据 |
| 需要支持 context 取消 | 客户端断开时快速释放资源 |
| 高并发场景 | 避免 goroutine 数量爆炸 |
3. 缓冲 Channel - 生产者-消费者模式
特性说明
核心语义:
make(chan T, n)- 缓冲 channel,异步直到缓冲满- 缓冲大小为 1 时适合「只通知」场景(struct)
- 缓冲大小设为任务数,避免收集结果时阻塞
项目中的实际应用
应用位置 1: internal/app/app.go:199 - 信号处理
quit := make(chan os.Signal, 1) // 缓冲大小为1,足够接收 SIGINT/SIGTERM
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit // 阻塞直到收到信号应用位置 2: internal/service/websocket/websocket.go:195 - 心跳活动通知
activityUpdate := make(chan time.Time, 1) // 缓冲通道,避免阻塞
// 非阻塞写入:如果没人读,旧值被覆盖
activityUpdate <- time.Now()应用位置 3: internal/service/chat/chat.go:1437 - 收集并发查询结果
type mentionedMessageResult struct {
err error
messages []*model.Message
chatID primitive.ObjectID
}
mentionedMessageChan := make(chan mentionedMessageResult, len(chatIDs)) // 缓冲大小=任务数
// goroutine 写入不阻塞,最后统一关闭业务场景
- OS 信号接收:只关心「是否收到信号」,不需要丢失任何信号,缓冲大小 1 足够
- WebSocket 心跳:发送活动状态,如果上一次状态还没被消费,直接覆盖(只保留最新状态)
- 并发结果收集:预分配缓冲大小等于任务数,goroutine 写入不会阻塞,最后用
for range读取
适用场景
| 场景 | 缓冲大小 | 说明 |
|---|---|---|
| OS 信号接收 | 1 | 只关心最新信号 |
| 状态更新(心跳、位置) | 1 | 只保留最新状态 |
| 结果收集 | len(tasks) | 写入不阻塞 |
| 生产者-消费者 | 根据 qps 调整 | 削峰填谷 |
4. Worker Pool - 固定数量 Worker 消费任务队列
特性说明
核心语义:
- 预先创建固定数量的 worker goroutine
- 任务通过 channel 传递
- worker 长期运行,任务结束后不销毁
适用场景: 任务持续到达的生产者-消费者模型(如消息队列消费、定时任务)
项目中的实际应用
应用位置 1: internal/pkg/workerpool/workerpool.go:94-100
pool := &WorkerPool{
name: name,
maxWorkers: maxWorkers,
taskQueue: make(chan *Task), // 任务输入 channel
workerQueue: make(chan *Task), // Worker 领取任务
stopSignal: make(chan struct{}), // 停止信号
stoppedChan: make(chan struct{}), // 停止完成通知
}Worker 消费模式:
func worker(task *Task, workerQueue chan *Task, wg *sync.WaitGroup, pool *WorkerPool) {
defer wg.Done()
for {
select {
case t := <-workerQueue:
// 处理任务
process(t)
case <-pool.stopSignal:
return
}
}
}应用位置 2: internal/service/subscription/scheduler.go:48-79 - 定时任务调度
stopChan := make(chan struct{})
ticker := time.NewTicker(1 * time.Hour)
for {
select {
case <-ticker.C:
// 执行定时任务
s.processScheduledTasks()
case <-stopChan:
return
}
}业务场景
- Kafka 消息消费:固定 N 个 worker 从 Kafka topic 消费消息,保持稳定消费速率
- 定时任务调度:每小时执行一次清理任务,支持优雅关闭(等当前任务完成后才退出)
适用场景
| 场景 | 说明 |
|---|---|
| 消息队列消费 | Kafka、SQS、Redis stream 消费者 |
| 定时任务处理 | 周期性的数据清理、报表生成 |
| 长连接管理 | WebSocket 连接池、数据库连接池 |
| 任务分发 | 任务量大但资源有限,需要均匀分配 |
5. sync.Once - 单次初始化
特性说明
核心语义:
- 保证函数只执行一次
- 多个 goroutine 同时调用时,只有一个会执行,其他等待
- 常用于单例模式、延迟加载
项目中的实际应用
应用位置 1: pkg/utils/snowflake/snowflake.go:15-32
var once sync.Once
func NewSnowflakeIDGenerator(nodeID int64) (*SnowflakeIDGenerator, error) {
var initErr error
once.Do(func() {
// 只会执行一次
if err := initSnowflake(nodeID); err != nil {
initErr = err
return
}
initialized = true
})
if initErr != nil {
return nil, initErr
}
return generator, nil
}应用位置 2: internal/logger/logger.go:21
var once sync.Once
func Init() {
once.Do(func() {
// 只会初始化一次
logger = zap.New(...)
})
}应用位置 3: internal/pkg/workerpool/workerpool.go:165 - 确保只停止一次
stopOnce sync.Once // 保证 stop 操作只执行一次业务场景
- Snowflake ID 生成器:初始化时设置 nodeID,多次调用不会重复初始化
- Logger 初始化:应用启动时初始化,多个组件可能同时调用
- 优雅关闭:确保清理操作只执行一次
适用场景
| 场景 | 说明 |
|---|---|
| 单例模式 | 数据库连接、Redis 连接、ID 生成器 |
| 延迟加载 | 第一次使用时才初始化 |
| 一次性资源 | 启动时加载配置、注册清理函数 |
6. sync.Mutex / RWMutex - 并发安全
特性说明
| 类型 | 适用场景 |
|---|---|
sync.Mutex | 写少读多 or 每次只有一个 goroutine 写 |
sync.RWMutex | 读多写少,可以多个读者并行 |
项目中的实际应用
应用位置 1: internal/pkg/workerpool/workerpool.go:164-165
type WorkerPool struct {
mu sync.RWMutex // 保护 metrics(读多写少)
stopLock sync.Mutex // 保护 stop 操作
stopOnce sync.Once // 确保 stop 只执行一次
}应用位置 2: internal/pkg/websocket/connection_manager.go:44
type Connection struct {
writeMutex sync.Mutex // 保护并发写 WebSocket
}
// 写入时加锁
func (c *Connection) WriteMessage(msg []byte) error {
c.writeMutex.Lock()
defer c.writeMutex.Unlock()
return c.conn.WriteMessage(msg)
}应用位置 3: internal/service/message/message.go:3021
var mu sync.Mutex
var allUpdatedMessageIDs []string
// 写入时加锁
mu.Lock()
allUpdatedMessageIDs = append(allUpdatedMessageIDs, messageIDsToUpdate...)
mu.Unlock()业务场景
- WebSocket 并发写:
WriteMessage不是线程安全的,需要加锁保护 - Metrics 读取:多个 goroutine 读取指标,但更新较少,用 RWMutex 可并发读
- 批量结果收集:多个 goroutine 并发写结果到 slice,需要加锁
适用场景
| 场景 | 推荐类型 |
|---|---|
| WebSocket 写入 | sync.Mutex |
| 计数器更新 | sync.Mutex |
| 配置读取 | sync.RWMutex |
| 结果收集 | sync.Mutex + 预分配数组(更优) |
7. Context 取消传播
特性说明
核心语义:
context.WithCancel- 创建可取消的 contextcontext.WithTimeout- 创建带超时的 contextcontext.WithValue- 传递请求级别的数据(如 traceID、userID)
项目中的实际应用
应用位置 1: internal/mw/tracking/tracking.go:159 - 下游调用超时控制
reportCtx, cancel := context.WithTimeout(spanCtx, 2*time.Second)
defer cancel()
// 传给下游调用,下游收到取消信号会立即终止应用位置 2: internal/mw/redis/redis.go:49 - Redis 连接超时
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// Redis 操作会在 5 秒后超时应用位置 3: internal/dal/init.go:24 - MongoDB 连接超时
ctx, cancel := context.WithTimeout(context.Background(), config.ConnectTimeout)
defer cancel()
// MongoDB driver 会尊重这个 context业务场景
- 追踪服务调用下游:设置 2 秒超时,防止下游拖慢整体响应
- 数据库连接:设置连接超时,避免无限等待
- HTTP 客户端:设置请求超时,自动取消
适用场景
| 场景 | 推荐 |
|---|---|
| HTTP 客户端调用 | WithTimeout |
| 数据库操作 | WithTimeout |
| 链路追踪 | WithValue 传递 traceID |
| 优雅关闭 | WithCancel |
8. 业务场景与并发特性对照表
| 业务场景 | 推荐特性 | 原因 |
|---|---|---|
| 批量查询多个独立数据源(统计页面) | errgroup | 快速并行获取,一个失败整体失败 |
| 聊天室更新 N 个成员的非阅读计数 | semaphore (maxConcurrency=50) | 限制并发数,避免资源耗尽 |
| 消息推送给大量在线用户 | Worker Pool + semaphore | 固定 worker 数,均衡负载 |
| 定时任务调度 | select + ticker + stopChan | 优雅停止 |
| 单例初始化(ID 生成器、Logger) | sync.Once | 保证只执行一次 |
| WebSocket 并发写 | sync.Mutex | 保护非线程安全的操作 |
| 并发查询 DB 后聚合结果 | WaitGroup + 预分配结果数组 | 结果按 index 回填,不依赖执行顺序 |
| 调用外部 API 有超时要求 | context.WithTimeout | 自动取消,避免无限等待 |
| Kafka 消息消费 | Worker Pool | 固定消费者数量,持续消费 |
| 配置只读一次 | sync.RWMutex | 读多写少,并发友好 |
9. 你的代码中已有的优化模式
从 chat.go 和 message.go 看,你已经在使用以下优化模式:
模式 1: Channel-based semaphore
const maxConcurrency = 50
sem := make(chan struct{}, maxConcurrency)
var wg sync.WaitGroup
for _, item := range items {
wg.Add(1)
go func() {
defer wg.Done()
sem <- struct{}{}
defer func() { <-sem }()
// 执行任务
}()
}
wg.Wait()模式 2: WaitGroup + 预分配结果数组
results := make([]Result, len(items)) // 预分配
var wg sync.WaitGroup
for i, item := range items {
wg.Add(1)
go func(idx int, it Item) {
defer wg.Done()
results[idx] = process(it) // 按 index 回填,不依赖执行顺序
}(i, item)
}
wg.Wait()模式 3: Buffered channel 收集结果
results := make(chan Result, len(items)) // 缓冲大小=任务数
var wg sync.WaitGroup
for _, item := range items {
wg.Add(1)
go func() {
defer wg.Done()
results <- process(item) // 不阻塞
}()
}
wg.Wait()
close(results)
for r := range results { // 读取所有结果
// 处理结果
}模式 4: errgroup 并行查询
g, gctx := errgroup.WithContext(ctx)
g.Go(func() error {
data1, err := repo.Query1(gctx)
return err
})
g.Go(func() error {
data2, err := repo.Query2(gctx)
return err
})
if err := g.Wait(); err != nil {
return nil, err
}10. 哪些场景可以考虑升级
可以考虑引入 ants 的场景
| 场景 | 原因 |
|---|---|
| 每秒上百次 batch 任务 | 减少 goroutine 创建销毁开销 |
| 大量短任务(<10ms) | worker 复用减少调度开销 |
| 需要统一的 panic 处理 | WithPanicHandler 避免进程崩溃 |
| 超大并发量(>10000) | MultiPool 减少单池锁竞争 |
建议继续用原生模式的场景
| 场景 | 原因 |
|---|---|
| 单次 HTTP 请求内的 batch | 请求结束就结束,复用收益不明显 |
| 20 条左右的批量处理 | WaitGroup + semaphore 够清晰、好测 |
| 任务执行时间差异大 | 无界 worker pool 会导致任务堆积 |
可以考虑 semaphore 官方库的场景
| 场景 | 原因 |
|---|---|
| 需要支持权重(不同任务消耗不同资源) | Weighted 支持不同权重 |
| 需要在 select 中监听 | Acquire 返回 error 可直接用 |
| 需要更精确的取消控制 | context 取消时立即返回 error |
总结
| 特性 | 一句话总结 | 典型业务场景 |
|---|---|---|
errgroup | 并行执行 + 一个失败全部取消 | 统计页面、依赖查询 |
semaphore | 限制同时执行的任务数 | 批量更新、外部 API 限流 |
Worker Pool | 固定 worker 长期消费任务 | Kafka 消费、定时任务 |
sync.Once | 保证只执行一次 | 单例初始化 |
sync.Mutex | 保护共享状态的写入 | WebSocket 写入、计数器 |
sync.RWMutex | 读多写少场景的并发读取 | 配置读取、缓存读取 |
Context | 超时和取消传播 | 数据库操作、外部 API 调用 |
Buffered Channel | 异步传递 + 削峰填谷 | 结果收集、状态通知 |
并发优化
This document analyzes the message.go and chat.go service files and provides optimization recommendations using Go's advanced concurrency features.
1. Media Upload Polling → Redis Pub/Sub Event-Driven
Current Implementation (message.go:1426-1461)
func (s *messageService) waitForMediaUploadAndPush(ctx context.Context, message *model.Message) {
ticker := time.NewTicker(200 * time.Millisecond) // Check every 200 milliseconds
defer ticker.Stop()
timeout := time.After(10 * time.Second)
for {
select {
case <-ticker.C:
uploadStatus, err := s.messageRepo.GetMessageMediaUploadStatus(ctx, message.ID)
// ... check status
if uploadStatus == "completed" {
s.asyncPushMessageToUsers(ctx, message)
return
}
case <-timeout:
// ... timeout handling
case <-ctx.Done():
return
}
}
}Problems
- Wastes CPU cycles: Polling every 200ms for up to 10 seconds = up to 50 unnecessary DB queries per message
- Scales poorly: Under high load, thousands of goroutines are blocked on polling
- No real-time notification: If upload completes at 500ms, we wait until the next tick at 600ms
Optimization: Redis Pub/Sub
// Redis key for media upload completion event
const mediaUploadCompletedKey = "media:upload:completed:%s" // messageID
// Publisher: After media upload completes, publish event
func (s *messageService) publishMediaUploadCompleted(ctx context.Context, messageID string) error {
return s.redisClient.Publish(ctx, fmt.Sprintf(mediaUploadCompletedKey, messageID), "completed").Err()
}
// Subscriber: Listen for upload completion instead of polling
func (s *messageService) waitForMediaUploadAndPush(ctx context.Context, message *model.Message) {
channel := fmt.Sprintf(mediaUploadCompletedKey, message.ID.Hex())
// Subscribe with context cancellation
pubsub := s.redisClient.Subscribe(ctx, channel)
defer pubsub.Close()
// Check if already completed (race condition guard)
status, err := s.messageRepo.GetMessageMediaUploadStatus(ctx, message.ID)
if err == nil && status == "completed" {
s.asyncPushMessageToUsers(ctx, message)
return
}
timeout := time.After(10 * time.Second)
select {
case msg := <-pubsub.Channel():
if msg.Payload == "completed" {
s.asyncPushMessageToUsers(ctx, message)
return
}
case <-timeout:
s.asyncPushMessageToUsers(ctx, message) // Push anyway with pending status
case <-ctx.Done():
return
}
}Benefits
- Zero CPU waste: No polling, instant notification on upload completion
- Lower latency: Message pushes immediately when upload finishes
- Better scalability: Goroutines block on Redis subscription, not CPU
2. Message Read Status Batch Update → errgroup with Batching
Current Implementation (message.go:2728-2743)
allUpdatedMessageIDs := []string{}
wg := sync.WaitGroup{}
wg.Add(len(messageIDsToUpdate))
for _, messageID := range messageIDsToUpdate {
go func(messageID string) {
defer wg.Done()
updateErr := s.update1To1MessageReadStatus(ctx, messageID, readByUserID, chatID, readAt)
if updateErr != nil {
logger.Errorf("...")
return
}
allUpdatedMessageIDs = append(allUpdatedMessageIDs, messageID) // Not thread-safe!
}(messageID)
}
wg.Wait()Problems
- Race condition:
allUpdatedMessageIDsis appended from multiple goroutines without synchronization - No error handling coordination:
errgroupwould provide better error collection - Individual DB calls: Each message update is a separate DB query
Optimization: errgroup with Batch Processing
import "golang.org/x/sync/errgroup"
func (s *messageService) processMessageReads(ctx context.Context, taskData *types.MessageReadTaskData) error {
// ... setup code ...
// Batch the message IDs for efficient DB update
const batchSize = 50
messageIDs := messageIDsToUpdate
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(10) // Limit concurrent batches
results := make([]string, 0, len(messageIDs))
var mu sync.Mutex // Only protects the results slice
for i := 0; i < len(messageIDs); i += batchSize {
batch := messageIDs[i:min(i+batchSize, len(messageIDs))]
batch := append([]string{}, batch...) // Copy to avoid slice aliasing
g.Go(func() error {
// Batch update in a single DB call
updatedIDs, err := s.batchUpdate1To1MessageReadStatus(ctx, batch, readByUserID, chatID, readAt)
if err != nil {
return err
}
mu.Lock()
results = append(results, updatedIDs...)
mu.Unlock()
return nil
})
}
if err := g.Wait(); err != nil {
return err
}
// Push Kafka notification for read status
if len(results) > 0 {
messageReadData := &types.MessageReadData{
ReadType: taskData.ReadType,
ReadAt: readAt,
ReadMessageIDs: results,
ChatID: chatID,
ReadByUserID: readByUserID,
ReadCount: len(results),
}
return s.kafkaProducerService.SendFeedMessage(ctx, kafkaModel.KafkaMessageTypeMessageRead, []string{taskData.MessageSenderID}, messageReadData, &readByUserID)
}
return nil
}Benefits
- Thread-safe: Mutex protects shared results slice
- Context cancellation: errgroup cancels all tasks if one fails
- Batching: Reduces DB round trips from N to N/batchSize
- Concurrency limit:
SetLimit(10)prevents overwhelming the DB
3. Same Race Condition in filterNeedToProcessMessageReadMessageIDs
Current Implementation (message.go:2960-2974)
messageIDsToUpdate := []string{}
wg := sync.WaitGroup{}
wg.Add(len(messageIDs))
for _, messageID := range messageIDs {
go func(messageID string) {
defer wg.Done()
isAlreadyRead := s.IsMessageAlreadyRead(ctx, messageID, readByUserID, chatType)
// ...
messageIDsToUpdate = append(messageIDsToUpdate, messageID) // NOT THREAD-SAFE!
}(messageID)
}
wg.Wait()Problems
- Same race condition:
messageIDsToUpdateis appended without synchronization - Error handling missing: Errors from
IsMessageAlreadyReadare silently ignored
Optimization: Use errgroup with Thread-Safe Collection
func (s *messageService) filterNeedToProcessMessageReadMessageIDs(ctx context.Context, taskData *types.MessageReadTaskData) ([]string, error) {
// ... initial filtering ...
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(20) // Limit concurrent checks
var mu sync.Mutex
messageIDsToUpdate := make([]string, 0, len(messageIDs))
for _, messageID := range messageIDs {
messageID := messageID // Capture loop variable
g.Go(func() error {
isAlreadyRead, err := s.IsMessageAlreadyRead(ctx, messageID, readByUserID, chatType)
if err != nil {
return err // Propagate error
}
if !isAlreadyRead {
mu.Lock()
messageIDsToUpdate = append(messageIDsToUpdate, messageID)
mu.Unlock()
}
return nil
})
}
if err := g.Wait(); err != nil {
return nil, err
}
// ... rest of the function ...
}4. Sequential Pagination → Concurrent Paginated Fetch
Current Implementation (chat.go:2971-3011)
for len(uniqueListingKeys) < size {
messages, totalMsg, err := s.messageRepo.GetMentionedNSharingListingMessages(ctx, chatID, page, size, senderIDs)
if err != nil {
return nil, err
}
if len(messages) == 0 {
break
}
// ... process messages ...
if len(uniqueListingKeys) >= size || int64(len(allMessages)) >= totalMsg {
break
}
page++
}Problems
- Sequential execution: Each page is fetched one after another
- Blocked on network/DB: Cannot start next page until current completes
- No parallelism: Underutilizes network latency opportunity
Optimization: Concurrent Page Fetching
func (s *chatService) GetLastListingMessagesConcurrent(ctx context.Context, chatID primitive.ObjectID, userID primitive.ObjectID, size int) ([]*model.Message, error) {
senderIDs, err := s.getAgentAndBotUserIDs(ctx, chatID, userID)
if err != nil {
return nil, err
}
if len(senderIDs) == 0 {
return []*model.Message{}, nil
}
const pageSize = 20
const maxConcurrentPages = 5
results := make([]*model.Message, 0, size)
uniqueListingKeys := make(map[string]bool)
var mu sync.Mutex
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(maxConcurrentPages)
// Channel to receive pages
pageChan := make(chan []*model.Message, maxConcurrentPages)
// First, fetch initial page to get total count
firstPage, total, err := s.messageRepo.GetMentionedNSharingListingMessages(ctx, chatID, 1, pageSize, senderIDs)
if err != nil {
return nil, err
}
if len(firstPage) == 0 {
return []*model.Message{}, nil
}
// Process first page
go func(msgs []*model.Message) {
pageChan <- msgs
}(firstPage)
// Launch goroutines for remaining pages
for page := 2; int64((page-1)*pageSize) < total; page++ {
page := page // Capture
g.Go(func() error {
messages, err := s.messageRepo.GetMentionedNSharingListingMessages(ctx, chatID, page, pageSize, senderIDs)
if err != nil {
return err
}
pageChan <- messages
return nil
})
}
// Close channel when all goroutines complete
go func() {
g.Wait()
close(pageChan)
}()
// Process results as they arrive
for messages := range pageChan {
mu.Lock()
for _, msg := range messages {
if len(uniqueListingKeys) >= size {
mu.Unlock()
return results, nil
}
results = append(results, msg)
// Track unique listing keys
if msg.MentionInfo != nil {
for _, key := range msg.MentionInfo.MentionedPublicListings {
uniqueListingKeys[key] = true
}
}
if msg.MessageType == model.MessageTypeSharePublicListing && msg.PublicListingInfo != nil {
uniqueListingKeys[msg.PublicListingInfo.ListingKey] = true
}
}
mu.Unlock()
}
return results, nil
}Benefits
- Parallel page fetching: Up to 5 pages fetched concurrently
- Early termination: Stops when enough unique listings collected
- Non-blocking: Processes pages as they arrive, not after all complete
5. In-Memory Task Queue → Kafka-based Task Distribution
Current Implementation (TODO comments at message.go:2548, 2606)
// TODO: @ethan, need use message queue like sqs or kafka to submit task, not memory queue
err := s.SubmitMessageReadTask(task)Problem
- In-memory queues can lose tasks on crash
- No horizontal scaling (single instance)
- Memory pressure under high load
Optimization: Kafka Producer for Task Distribution
// Instead of in-memory queue submission
// Submit to Kafka topic for distributed processing
func (s *messageService) SubmitMessageReadTaskToKafka(ctx context.Context, task *MessageReadTask) error {
taskData, err := json.Marshal(task.MessageReadData)
if err != nil {
return fmt.Errorf("marshal task: %w", err)
}
return s.kafkaProducerService.SendToTopic(ctx, "message-read-tasks", &kafka.Message{
Key: task.MessageReadData.ChatID, // Partition by chatID for ordering
Value: taskData,
})
}
// Kafka consumer (in a separate worker service) processes tasks
func (s *messageReadWorker) ProcessMessages(ctx context.Context) error {
for {
select {
case msg, ok := <-s.consumer.Messages():
if !ok {
return ctx.Err()
}
var taskData types.MessageReadTaskData
if err := json.Unmarshal(msg.Value, &taskData); err != nil {
logger.Errorf("unmarshal task: %v", err)
continue
}
// Process with backoff retry
if err := s.processWithRetry(ctx, &taskData); err != nil {
logger.Errorf("process task failed after retries: %v", err)
// Send to dead letter queue
s.sendToDLQ(ctx, msg.Value)
}
s.consumer.CommitMessages(ctx, msg)
case <-ctx.Done():
return ctx.Err()
}
}
}Benefits
- Durability: Tasks survive service restarts
- Horizontal scaling: Multiple workers can consume from same topic
- Backpressure: Kafka handles overload via consumer lag
6. Basic WaitGroup → errgroup for Chat List Loading
Current Implementation (chat.go:2210-2250)
wg := sync.WaitGroup{}
wg.Add(2)
go func() {
defer wg.Done()
chatMembersMap, memberErr = s.chatMemberRepository.GetChatMemberIDsByChatIDs(ctx, chatIDs)
}()
go func() {
defer wg.Done()
chatLastMessageMap, lastMessageErr = s.messageRepo.GetChatLastMessageByChatIDs(ctx, chatIDs)
}()
wg.Wait()
if memberErr != nil {
return nil, memberErr
}
if lastMessageErr != nil {
return nil, lastMessageErr
}Problem
- WaitGroup doesn't propagate errors to context
- Both tasks run even if one fails early
- Error handling is manual and error-prone
Optimization: errgroup.WithContext
import "golang.org/x/sync/errgroup"
func (s *chatService) getChatListData(ctx context.Context, userID primitive.ObjectID, req types.GetChatListRequest) (*types.ChatListData, error) {
// ... setup ...
g, ctx := errgroup.WithContext(ctx)
var (
chatMembersMap map[primitive.ObjectID][]primitive.ObjectID
chatLastMessageMap map[primitive.ObjectID]*model.Message
)
g.Go(func() error {
var err error
chatMembersMap, err = s.chatMemberRepository.GetChatMemberIDsByChatIDs(ctx, chatIDs)
if err != nil {
return fmt.Errorf("get chat members: %w", err)
}
return nil
})
g.Go(func() error {
var err error
chatLastMessageMap, err = s.messageRepo.GetChatLastMessageByChatIDs(ctx, chatIDs)
if err != nil {
return fmt.Errorf("get last messages: %w", err)
}
return nil
})
// If either goroutine fails, context is cancelled and function returns
if err := g.Wait(); err != nil {
return nil, err
}
// Use the results...
return &types.ChatListData{
// ... populate results ...
}, nil
}Benefits
- Automatic cancellation: If one goroutine fails, the other is cancelled via context
- Single error return: No manual error variable tracking
- Cleaner code: No shared error variables
7. Fire-and-Forget Goroutines → Semaphore-Controlled Concurrency
Current Implementation (message.go:1795-1817)
// Increment unread count for all members except sender
for _, memberID := range chatMemberIDs {
if memberID == message.SenderID {
continue // Skip sender
}
memberIDStr := memberID.Hex()
// Use goroutine for concurrent updates
go func(uid string) {
_, err := s.readCacheService.IncrChatUnreadCount(ctx, chatIDStr, uid)
if err != nil {
logger.Errorf("Failed to increment unread count cache - ChatID: %s, UserID: %s, Error: %v", chatIDStr, uid, err)
}
}(memberIDStr)
}Problem
- Unlimited goroutines: If a chat has 1000 members, creates 1000 concurrent goroutines
- No backpressure: Can overwhelm Redis under high load
- Resource exhaustion: Memory and scheduler pressure from too many concurrent operations
Optimization: Semaphore with Limited Concurrency
// updateUnreadCountCacheForNewMessage updates unread count cache for all chat members when a new message is sent.
func (s *messageService) updateUnreadCountCacheForNewMessage(ctx context.Context, message *model.Message, _ *model.Chat) {
defer func() {
if r := recover(); r != nil {
logger.Errorf("updateUnreadCountCacheForNewMessage panic recovered: %v, MessageID: %s", r, message.ID.Hex())
}
}()
// Skip system messages
if message.MessageSource == model.MessageSourceSystem {
return
}
chatMemberIDs, err := s.chatMemberService.GetChatMemberIDs(ctx, message.ChatID)
if err != nil {
logger.Errorf("Failed to get chat members for unread count update - ChatID: %s, Error: %v", message.ChatID.Hex(), err)
return
}
chatIDStr := message.ChatID.Hex()
// Use semaphore to limit concurrent goroutines
const maxConcurrency = 50
semaphore := make(chan struct{}, maxConcurrency)
var wg sync.WaitGroup
for _, memberID := range chatMemberIDs {
if memberID == message.SenderID {
continue
}
memberIDStr := memberID.Hex()
wg.Add(1)
go func(uid string) {
defer wg.Done()
// Acquire semaphore
semaphore <- struct{}{}
defer func() { <-semaphore }()
_, err := s.readCacheService.IncrChatUnreadCount(ctx, chatIDStr, uid)
if err != nil {
logger.Errorf("Failed to increment unread count cache - ChatID: %s, UserID: %s, Error: %v", chatIDStr, uid, err)
}
}(memberIDStr)
}
wg.Wait()
logger.Infof("Updated unread count cache for %d members in chat %s", len(chatMemberIDs)-1, chatIDStr)
}Benefits
- Backpressure: Limits concurrent operations to a reasonable number
- Predictable resource usage: Memory and scheduler usage bounded regardless of chat size
- Still concurrent: Still processes updates in parallel, just not unbounded parallel
9. Sequential User Info Fetching → Parallel Batch Fetching
Current Implementation (message.go:3563-3585)
func (s *messageService) buildChatHistory(ctx context.Context, chatID, messageID primitive.ObjectID, limit int) ([]string, error) {
chatHistoryMessages := make([]string, 0)
historyMessages, err := s.messageRepo.GetChatMessageListWithCursor(ctx, chatID, messageID, limit, nil)
if err != nil {
return chatHistoryMessages, nil
}
historyMessages = lo.Filter(historyMessages, func(item *model.Message, _ int) bool {
return !item.IsDeleted && item.MessageSource != model.MessageSourceSystem
})
for _, histMsg := range historyMessages {
senderInfo, _ := s.userService.GetUserBasicInfo(ctx, histMsg.SenderID)
chatHistoryMessages = append(chatHistoryMessages, fmt.Sprintf("%s : %s", senderInfo.Username, histMsg.Content))
}
return chatHistoryMessages, nil
}Problem
- Sequential user fetching: For 20 messages, makes 20 sequential DB/service calls
- No batching: Each user info fetched individually
Optimization: Batch Fetch All User Info
func (s *messageService) buildChatHistory(ctx context.Context, chatID, messageID primitive.ObjectID, limit int) ([]string, error) {
chatHistoryMessages := make([]string, 0)
historyMessages, err := s.messageRepo.GetChatMessageListWithCursor(ctx, chatID, messageID, limit, nil)
if err != nil {
return chatHistoryMessages, nil
}
historyMessages = lo.Filter(historyMessages, func(item *model.Message, _ int) bool {
return !item.IsDeleted && item.MessageSource != model.MessageSourceSystem
})
if len(historyMessages) == 0 {
return chatHistoryMessages, nil
}
// Batch fetch all sender IDs
senderIDs := make([]primitive.ObjectID, 0, len(historyMessages))
for _, msg := range historyMessages {
senderIDs = append(senderIDs, msg.SenderID)
}
// Batch fetch all user info in one call
userMap, err := s.userService.GetUserSBasicInfoMap(ctx, senderIDs)
if err != nil {
logger.Warnf("failed to batch get user info: %v", err)
userMap = make(map[primitive.ObjectID]*model.User)
}
// Build chat history using pre-fetched user info
for _, histMsg := range historyMessages {
senderInfo := userMap[histMsg.SenderID]
username := "Unknown"
if senderInfo != nil {
username = senderInfo.Username
}
chatHistoryMessages = append(chatHistoryMessages, fmt.Sprintf("%s : %s", username, histMsg.Content))
}
return chatHistoryMessages, nil
}Benefits
- Batch operation: Reduces N service calls to 1
- Faster: Parallel fetching would be even faster for large histories
- Less load: Reduced pressure on user service
Go Concurrency Patterns Reference
1. errgroup for Coordinated Goroutines
import "golang.org/x/sync/errgroup"
g, ctx := errgroup.WithContext(ctx)
g.Go(func() error {
// Task 1
return nil
})
g.Go(func() error {
// Task 2
return nil
})
if err := g.Wait(); err != nil {
// Handle error
}When to use: When multiple tasks can run in parallel and you need to handle errors collectively.
2. sync.WaitGroup for Fire-and-Forget
var wg sync.WaitGroup
wg.Add(3)
go func() {
defer wg.Done()
// Work
}()
wg.Wait() // Blocks until all doneWhen to use: When you don't need error handling, just need to wait for completion.
3. Semaphore Pattern with Channel
const maxConcurrency = 50
semaphore := make(chan struct{}, maxConcurrency)
for _, item := range items {
wg.Add(1)
go func(item Item) {
defer wg.Done()
semaphore <- struct{}{} // Acquire
defer func() { <-semaphore }() // Release
// Work with item
}(item)
}
wg.Wait()When to use: When you need to limit concurrent operations to prevent overwhelming resources.
4. Worker Pool Pattern
func workerPool(jobs <-chan Job, results chan<- Result, numWorkers int) {
var wg sync.WaitGroup
for i := 0; i < numWorkers; i++ {
wg.Add(1)
go func() {
defer wg.Done()
for job := range jobs {
results <- process(job)
}
}()
}
wg.Wait()
close(results)
}When to use: When you have a stream of work items and want to limit concurrency.
5. Context for Cancellation and Timeouts
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
// All operations respect the timeout
result, err := doWork(ctx)When to use: Always, for graceful shutdown and preventing goroutine leaks.
6. Channel-based Pub/Sub
// Publisher
s.redisClient.Publish(ctx, channel, message)
// Subscriber
pubsub := s.redisClient.Subscribe(ctx, channel)
defer pubsub.Close()
msg := <-pubsub.Channel()When to use: Instead of polling, for real-time event notification.
7. sync.Mutex for Shared State
var mu sync.Mutex
sharedState := []string{}
mu.Lock()
sharedState = append(sharedState, "item")
mu.Unlock()When to use: When multiple goroutines need to modify shared data.
Summary of Optimizations
| Location | Current | Optimized | Improvement |
|---|---|---|---|
| Media upload wait | Polling (200ms intervals) | Redis Pub/Sub | ~50x fewer DB calls, instant notification |
| Message read update | Sequential goroutines with race | errgroup + batching | Thread-safe, fewer DB calls |
| filterNeedToProcessMessageReadMessageIDs | Race condition | errgroup with mutex | Thread-safe collection |
| Listing message fetch | Sequential pagination | Concurrent page fetch | ~5x faster for large lists |
| Task queue | In-memory (TODO) | Kafka-based | Durable, horizontally scalable |
| Chat list loading | WaitGroup | errgroup.WithContext | Automatic cancellation on error |
| Unread count update | Unlimited goroutines | Semaphore-controlled | Bounded resource usage |
| FCM push | WaitGroup with race | errgroup with error collection | Thread-safe, better error handling |
| Chat history building | Sequential user fetching | Batch fetching | 1 call instead of N |
Anti-Patterns to Avoid
1. Race Conditions on Shared Variables
// BAD: Unsynchronized append
allUpdatedMessageIDs = append(allUpdatedMessageIDs, messageID)
// GOOD: Protected by mutex
mu.Lock()
allUpdatedMessageIDs = append(allUpdatedMessageIDs, messageID)
mu.Unlock()2. Unbounded Goroutine Creation
// BAD: Creates N goroutines for N items
for _, item := range items {
go process(item)
}
// GOOD: Limited concurrency
semaphore := make(chan struct{}, maxConcurrency)
for _, item := range items {
go func(item Item) {
semaphore <- struct{}{}
defer func() { <-semaphore }()
process(item)
}(item)
}3. Ignoring Errors in Goroutines
// BAD: Errors silently ignored
go func() {
s.doSomething(ctx, item)
}()
// GOOD: Errors propagated via errgroup
g.Go(func() error {
return s.doSomething(ctx, item)
})