360龙虾算力豆在高并发场景下的架构优化实践

1次阅读

没有评论

共计 2161 个字符，预计需要花费 6 分钟才能阅读完成。

360 龙虾算力豆的核心计算逻辑涉及到复杂的哈希运算和资源调度算法。在高并发场景下，我们发现以下典型瓶颈：

CPU 密集型计算 ：每个算力豆请求都需要执行多次 SHA-256 哈希运算，导致单个请求处理时间较长
共享状态竞争 ：算力分配计数器存在严重的锁竞争
数据库压力 ：每次计算都需要查询用户配额和计费信息

实测在 4 核 8G 的服务器上，原生版本只能支撑约 800 QPS，且随着并发量增加，响应时间呈指数级增长。

我们对比了两种处理模式：

同步处理模式
优点：实现简单，数据强一致
缺点：吞吐量受限于计算耗时，无法应对突发流量
异步处理模式
优点：削峰填谷，资源利用率高
缺点：实现复杂，存在数据延迟

最终采用混合架构：

前端快速响应 ：使用多级缓存（本地缓存 +Redis）处理高频查询
后端异步计算 ：通过 RabbitMQ 实现任务队列，Worker 集群消费
状态同步 ：通过 Redis Pub/Sub 实现计算状态通知

// 优化后的算力豆核心算法
func CalculateBean(userID string, params BeanParams) (BeanResult, error) {
    // 第一步：从本地缓存获取基础数据
    if val, ok := localCache.Get(userID); ok {base := val.(BaseData)
        // 并行计算各维度特征
        var wg sync.WaitGroup
        features := make([]Feature, len(params.Dimensions))

        for i, dim := range params.Dimensions {wg.Add(1)
            go func(idx int, d Dimension) {defer wg.Done()
                features[idx] = calculateFeature(base, d)
            }(i, dim)
        }
        wg.Wait()

        // 合并特征结果
        return aggregateFeatures(features), nil
    }
    // 缓存未命中处理...
}

type CacheManager struct {
    localCache *freecache.Cache
    redisConn  *redis.Client
}

func (c *CacheManager) GetWithFallback(key string, loader func() (interface{}, error)) (interface{}, error) {
    // 1. 先查本地缓存
    if val, err := c.localCache.Get(key); err == nil {return val, nil}

    // 2. 查 Redis
    if val, err := c.redisConn.Get(key).Result(); err == nil {
        // 回填本地缓存
        c.localCache.Set(key, val, 5*time.Minute)
        return val, nil
    }

    // 3. 回源加载
    data, err := loader()
    if err != nil {return nil, err}

    // 双写缓存
    c.redisConn.Set(key, data, 30*time.Minute)
    c.localCache.Set(key, data, 5*time.Minute)
    return data, nil
}

func StartWorker(poolSize int) {ch, _ := rabbitmq.Channel()
    msgs, _ := ch.Consume(
        "bean_queue",
        "",
        false, // auto-ack
        false,
        false,
        false,
        nil,
    )

    sem := make(chan struct{}, poolSize)

    for msg := range msgs {sem <- struct{}{}
        go func(m amqp.Delivery) {defer func() {<-sem}()

            var task BeanTask
            json.Unmarshal(m.Body, &task)

            // 处理计算任务
            result := processTask(task)

            // 发布结果
            redis.Publish("bean_result:"+task.RequestID, result)

            m.Ack(false)
        }(msg)
    }
}

测试环境：8 核 16G 服务器 × 3 台，Redis 集群 3 节点