Gin并发安全与锁优化

并发安全是Web服务的基础，合理的锁策略能保障安全同时最大化性能。

Gin并发安全设计

Context不可跨请求共享

// 错误：跨请求共享Context
var sharedContext *gin.Context

func handler(c *gin.Context) {
    sharedContext = c  // 危险！
}

// 正确：每个请求独立Context
func handler(c *gin.Context) {
    // Context仅在当前请求有效
    c.JSON(200, gin.H{"message": "ok"})
}

sync.Pool安全复用

// Context池设计
type Engine struct {
    pool sync.Pool
}

func (engine *Engine) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 1. 获取Context（可能来自池）
    c := engine.pool.Get().(*Context)

    // 2. 重置状态（确保干净）
    c.reset()

    // 3. 处理请求
    engine.handleHTTPRequest(c)

    // 4. 归还池（状态已重置）
    engine.pool.Put(c)
}

// reset确保并发安全
func (c *Context) reset() {
    c.Params = c.Params[:0]  // 清空，不释放内存
    c.handlers = nil
    c.Keys = nil             // 清空map
    c.Errors = c.Errors[:0]
}

锁类型选择

RWMutex应用

// 读多写少场景
type Cache struct {
    data map[string]string
    mu   sync.RWMutex
}

func (c *Cache) Get(key string) string {
    c.mu.RLock()         // 读锁，允许并发读
    defer c.mu.RUnlock()
    return c.data[key]
}

func (c *Cache) Set(key, value string) {
    c.mu.Lock()          // 写锁，互斥
    defer c.mu.Unlock()
    c.data[key] = value
}

// 中间件缓存
func CacheMiddleware(cache *Cache) gin.HandlerFunc {
    return func(c *gin.Context) {
        key := c.Request.URL.Path

        if cached := cache.Get(key); cached != "" {
            c.Data(200, "application/json", []byte(cached))
            c.Abort()
            return
        }

        c.Next()

        // 缓存响应
        if c.Writer.Status() == 200 {
            body := getResponseBody(c)
            cache.Set(key, body)
        }
    }
}

sync.Map应用

// 并发安全map
var rateLimiters sync.Map

func RateLimitMiddleware(limit int) gin.HandlerFunc {
    return func(c *gin.Context) {
        userID := c.GetString("userID")

        // 获取或创建限流器
        limiter, _ := rateLimiters.LoadOrStore(userID, NewLimiter(limit))

        if !limiter.(*Limiter).Allow() {
            c.JSON(429, gin.H{"error": "rate limit exceeded"})
            c.Abort()
            return
        }

        c.Next()
    }
}

atomic应用

// 无锁计数器
type Metrics struct {
    requests    atomic.Int64
    errors      atomic.Int64
    latencySum  atomic.Int64
}

func (m *Metrics) RecordRequest() {
    m.requests.Add(1)
}

func (m *Metrics) RecordError() {
    m.errors.Add(1)
}

func (m *Metrics) RecordLatency(d time.Duration) {
    m.latencySum.Add(int64(d))
}

// 中间件使用
func MetricsMiddleware(metrics *Metrics) gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()

        metrics.RecordRequest()

        c.Next()

        metrics.RecordLatency(time.Since(start))

        if c.Writer.Status() >= 400 {
            metrics.RecordError()
        }
    }
}

锁优化策略

减少锁持有时间

// 低效：锁内执行耗时操作
func badHandler(c *gin.Context) {
    mu.Lock()
    result := queryDatabase()  // 耗时操作在锁内
    mu.Unlock()
    c.JSON(200, result)
}

// 高效：最小化锁范围
func goodHandler(c *gin.Context) {
    mu.Lock()
    queryParams := buildQueryParams()
    mu.Unlock()

    result := queryDatabase(queryParams)  // 锁外执行
    c.JSON(200, result)
}

锁分段

// 低效：单一大锁
type BigCache struct {
    data map[string]string
    mu   sync.Mutex
}

// 高效：分段锁
type ShardedCache struct {
    shards [16]struct {
        data map[string]string
        mu   sync.RWMutex
    }
}

func hashKey(key string) int {
    h := fnv.New32a()
    h.Write([]byte(key))
    return int(h.Sum32()) % 16
}

func (c *ShardedCache) Get(key string) string {
    shard := c.shards[hashKey(key)]
    shard.mu.RLock()
    defer shard.mu.RUnlock()
    return shard.data[key]
}

避免锁竞争

// 低效：频繁获取锁
func badMiddleware(c *gin.Context) {
    mu.Lock()
    counter++
    mu.Unlock()

    c.Next()

    mu.Lock()
    counter++
    mu.Unlock()
}

// 高效：使用atomic
func goodMiddleware(c *gin.Context) {
    counter.Add(1)

    c.Next()

    counter.Add(1)
}

并发安全陷阱

map并发读写

// 错误：并发读写map
var userCache = map[string]*User{}

func handler(c *gin.Context) {
    userID := c.Param("id")
    userCache[userID] = getUser(userID)  // panic: concurrent map write
}

// 正确：使用sync.Map或加锁
var userCache sync.Map

func handler(c *gin.Context) {
    userID := c.Param("id")
    userCache.Store(userID, getUser(userID))
}

Context.Keys并发

// Context.Keys在请求期间安全，但：
// 1. 不要在goroutine中访问
// 2. 请求结束后会清空

func handler(c *gin.Context) {
    go func() {
        // 错误：goroutine访问Context.Keys
        userID := c.GetString("userID")  // 可能panic
    }()
}

// 正确：传递值而非Context
func handler(c *gin.Context) {
    userID := c.GetString("userID")
    go func(id string) {
        processAsync(id)  // 使用传递的值
    }(userID)
}

注意：Context在请求结束后立即归还池中，Keys会被清空。

要点总结

• Context仅在请求范围内有效，禁止跨请求共享
• 读多写少用RWMutex，简单计数用atomic
• sync.Map适合并发读写场景
• 减少锁持有时间，锁外执行耗时操作
• 分段锁减少锁竞争，提升并发性能
• 禁止在goroutine中访问Context数据