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

通识对照:Go netpoll 与 WebSocket 长连接通识

面试题集锦: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 库,主要包含:

  1. Upgrader 将 HTTP 连接升级为 WebSocket
  2. readPump 循环读取消息
  3. writePump 循环发送消息,配合 ping/pong 保活
  4. 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。


目录

  1. Goroutine
  2. Channel
  3. 同步原语:WaitGroup、Mutex、Once
  4. 有界并发:带缓冲 channel 与 semaphore
  5. errgroup
  6. Context 与取消
  7. 贴近业务的组合示例
  8. ants v2 协程池
  9. ants 与原生实现对比与选型
  10. 参考链接

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) }()
<-done

3. 同步原语: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 协程池

项目: github.com/panjf2000/ants

一句话: 固定容量复用大量 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{} + goants 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. 参考链接


文档为通用说明,与具体业务线模块版本无关;ants 具体 API 以 v2.12+ 的 pkg.go.dev 为准。


并发实践

结合项目实际代码讲解并发原语,帮助快速掌握并应用到具体业务场景。


目录

  1. errgroup - 并发子任务 + 错误传播与取消
  2. semaphore - 有界并发控制
  3. 缓冲 Channel - 生产者-消费者模式
  4. Worker Pool - 固定数量 Worker 消费任务队列
  5. sync.Once - 单次初始化
  6. sync.Mutex / RWMutex - 并发安全
  7. Context 取消传播
  8. 业务场景与并发特性对照表
  9. 你的代码中已有的优化模式
  10. 哪些场景可以考虑升级

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 的服务端代码。

两种实现方式:

  1. golang.org/x/sync/semaphore - 官方库,支持 context 取消和权重
  2. 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 写入不阻塞,最后统一关闭

业务场景

  1. OS 信号接收:只关心「是否收到信号」,不需要丢失任何信号,缓冲大小 1 足够
  2. WebSocket 心跳:发送活动状态,如果上一次状态还没被消费,直接覆盖(只保留最新状态)
  3. 并发结果收集:预分配缓冲大小等于任务数,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
    }
}

业务场景

  1. Kafka 消息消费:固定 N 个 worker 从 Kafka topic 消费消息,保持稳定消费速率
  2. 定时任务调度:每小时执行一次清理任务,支持优雅关闭(等当前任务完成后才退出)

适用场景

场景说明
消息队列消费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 操作只执行一次

业务场景

  1. Snowflake ID 生成器:初始化时设置 nodeID,多次调用不会重复初始化
  2. Logger 初始化:应用启动时初始化,多个组件可能同时调用
  3. 优雅关闭:确保清理操作只执行一次

适用场景

场景说明
单例模式数据库连接、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()

业务场景

  1. WebSocket 并发写:WriteMessage 不是线程安全的,需要加锁保护
  2. Metrics 读取:多个 goroutine 读取指标,但更新较少,用 RWMutex 可并发读
  3. 批量结果收集:多个 goroutine 并发写结果到 slice,需要加锁

适用场景

场景推荐类型
WebSocket 写入sync.Mutex
计数器更新sync.Mutex
配置读取sync.RWMutex
结果收集sync.Mutex + 预分配数组(更优)

7. Context 取消传播

特性说明

核心语义:

  • context.WithCancel - 创建可取消的 context
  • context.WithTimeout - 创建带超时的 context
  • context.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

业务场景

  1. 追踪服务调用下游:设置 2 秒超时,防止下游拖慢整体响应
  2. 数据库连接:设置连接超时,避免无限等待
  3. 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: allUpdatedMessageIDs is appended from multiple goroutines without synchronization
  • No error handling coordination: errgroup would 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: messageIDsToUpdate is appended without synchronization
  • Error handling missing: Errors from IsMessageAlreadyRead are 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 done

When 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

LocationCurrentOptimizedImprovement
Media upload waitPolling (200ms intervals)Redis Pub/Sub~50x fewer DB calls, instant notification
Message read updateSequential goroutines with raceerrgroup + batchingThread-safe, fewer DB calls
filterNeedToProcessMessageReadMessageIDsRace conditionerrgroup with mutexThread-safe collection
Listing message fetchSequential paginationConcurrent page fetch~5x faster for large lists
Task queueIn-memory (TODO)Kafka-basedDurable, horizontally scalable
Chat list loadingWaitGrouperrgroup.WithContextAutomatic cancellation on error
Unread count updateUnlimited goroutinesSemaphore-controlledBounded resource usage
FCM pushWaitGroup with raceerrgroup with error collectionThread-safe, better error handling
Chat history buildingSequential user fetchingBatch fetching1 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)
})