千万并发直播答题系统架构

一、项目概述

1.1 业务背景

"百万奖金答题"是直播平台的杀手级拉新手段——晚8点整，500万用户同时涌入直播间，主持人宣布题目，用户在10秒内作答，答对者共同分享奖金。这类活动的技术挑战与常规高并发场景完全不同：

• 脉冲式洪峰：从0到500万用户只用10秒，系统必须在这10秒内完成扩容、稳定服务、毫秒级延迟响应
• 强公平性要求：所有用户看到的倒计时必须完全一致，不能出现"有人提前3秒看到题目"的作弊漏洞
• 答案洪峰写入：500万用户在10秒内同时提交答案，系统需要在倒计时结束后立即判分并展示结果
• 零容忍的单点故障：答题活动开始后，任何服务中断都会引发海量用户投诉和退款

1.2 核心矛盾分析

直播答题系统的本质矛盾是"写入洪峰"与"读取一致性"的叠加：

1.3 核心指标

二、技术架构设计

2.1 整体时序流程

一场答题活动的完整时序：

2.1.1 系统整体架构与时序联动

下图把整场答题活动从 T-30s 到 T+12s 的端到端链路在架构视角下展开：用户终端通过 CDN 接入，与 Go 答题服务建立 WebSocket 长连接；题目与倒计时信号经 Redis Pub/Sub 在答题服务集群中同步广播；用户答案投递到 Kafka，由判分引擎批量消费；判分结果写入 Redis 排行榜，触发 WebSocket 广播 + 积分服务落库 + IM 通知主播。整体形成"推流 → 答题 → 判分 → 积分 → 通知"的闭环。

2.2 三层架构设计

• 接入层（CDN + Nginx）：题目HTML和静态资源通过CDN分发，减少源站压力；WebSocket长连接在接入层做会话保持
• 连接层（Go答题服务）：管理500万WebSocket长连接，每秒推送题目、倒计时信号；使用Redis Cluster做会话状态存储
• 判分层（Kafka + 判分引擎）：答案通过Kafka削峰，判分引擎批量处理，结果写入Redis并广播

2.3 公平性保障机制

直播答题最核心的问题是"公平性"——防止任何用户比其他人更早看到题目：

• 服务端倒计时：倒计时由服务端下发，客户端只能显示服务端传来的剩余时间，不允许本地倒计时
• 题目加密传输：题目内容在服务端加密，客户端只有在倒计时归零的瞬间才收到解密密钥
• 答案时间戳权威：客户端提交答案时附上本地时间戳，但以服务端接收时间戳为准（网络延迟补偿）
• 防重放攻击：每个问题有唯一Token，答案必须携带Token，服务端校验Token是否已被使用

三、核心技术挑战与解决方案

四、关键技术实现

4.1 答题服务WebSocket核心代码（Go）

// 答题服务核心：管理WebSocket连接 + 题目推送 + 答案接收
type QuizServer struct {
    quizEngine *QuizEngine
    wsPool     *WebSocketPool     // 连接池
    redis      *redis.Client
    kafka      *kafka.Writer
}

func (s *QuizServer) HandleWebSocket(conn *websocket.Conn, userId string) {
    defer conn.Close()
    
    // 1. 注册连接到连接池
    s.wsPool.Add(userId, conn)
    defer s.wsPool.Remove(userId)

    // 2. 心跳保活（每30秒ping一次）
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    conn.SetPongHandler(func(string) error {
        conn.SetReadDeadline(time.Now().Add(60 * time.Second))
        return nil
    })

    for {
        // 读取客户端消息
        _, msg, err := conn.ReadMessage()
        if err != nil {
            return  // 连接断开
        }

        // 解析消息类型
        var req QuestionAnswer
        if err := json.Unmarshal(msg, &req); err != nil {
            continue
        }

        switch req.Type {
        case "answer":
            // 提交答案 → 发送到Kafka（不阻塞等待判分）
            s.kafka.WriteMessages(context.Background(), &kafka.Message{
                Key:   []byte(userId),
                Value: msg,
            })
        case "heartbeat":
            // 心跳响应
        }
    }
}

// 广播题目（由Redis Pub/Sub触发）
func (s *QuizServer) BroadcastQuestion(question *Question, deadline int64) {
    // deadline = 服务端绝对时间戳（毫秒）
    broadcast := QuestionBroadcast{
        Type:     "question",
        QID:       question.ID,
        Content:   question.Content,
        Options:   question.Options,
        Deadline:  deadline,
        ServerTime: time.Now().UnixMilli(),
    }

    msg, _ := json.Marshal(broadcast)
    // 通过Redis Pub/Sub广播，答题服务器集群同时收到
    s.redis.Publish("quiz:question", string(msg))

    // 3秒后广播倒计时启动信号
    time.AfterFunc(3*time.Second, func() {
        ticker := QuestionBroadcast{
            Type:    "ticker_start",
            Deadline: deadline,
        }
        s.wsPool.Broadcast(ticker)  // 向所有连接推送
    })
}

4.2 判分消费者代码（Kafka批量处理）

// Kafka消费者：批量拉取答案 + 批量判分
type ScorerConsumer struct {
    kafkaReader *kafka.Reader
    redis       *redis.Client
    kafkaWriter *kafka.Writer  // 结果消息
}

func (c *ScorerConsumer) Start() {
    for {
        // 批量拉取：每次最多1000条答案
        msgs, err := c.kafkaReader.FetchMessages(context.Background(), 1000)
        if err != nil {
            log.Printf("拉取答案失败: %v", err)
            continue
        }

        // 批量判分
        results := make([]ScoreResult, 0, len(msgs))
        for _, msg := range msgs {
            var ans QuestionAnswer
            if err := json.Unmarshal(msg.Value, &ans); err != nil {
                continue
            }

            // 判分（Lua原子操作）
            result := c.judgeAnswer(ans)
            results = append(results, result)
        }

        // 批量写入Redis
        c.batchWriteResults(results)

        // 广播判分完成信号
        if len(results) > 0 {
            c.broadcastScoreComplete(results[0].QuestionID)
        }
    }
}

// Redis Lua原子判分
func (c *ScorerConsumer) judgeAnswer(ans QuestionAnswer) ScoreResult {
    key := fmt.Sprintf("quiz:answer:%s:%s", ans.QuestionID, ans.UserID)
    
    script := `
        local existing = redis.call('EXISTS', KEYS[1])
        if existing == 1 then
            return -1  -- 已答过
        end
        redis.call('SETEX', KEYS[1], 3600, ARGV[1])
        redis.call('INCR', KEYS[2])  -- 正确计数+1
        return 1
    `
    
    correctKey := fmt.Sprintf("quiz:correct:%s", ans.QuestionID)
    r := c.redis.Eval(script, []string{key, correctKey}, ans.Answer).Int()
    
    return ScoreResult{
        UserID:     ans.UserID,
        QuestionID:  ans.QuestionID,
        Answer:      ans.Answer,
        Correct:      r == 1,
        SubmitTime:  ans.SubmitTime,
    }
}

4.2.1 判分与积分服务数据流

下图把判分消费者代码映射到端到端数据流：用户在 WebSocket 上提交答案（携带 QID、UID、答案、时间戳），由 QuizServer 写入 Kafka 对应分区；ScorerConsumer 批量拉取 1000 条/次，调用 Redis Lua 完成"判分 + 防重放 + 正确数 +1"四步原子操作；结果分两路：一路 ZADD 排行榜 + 持久化 MySQL，另一路通过 Redis Pub/Sub 触发答题服务 WebSocket 广播；同时按题目配置的奖金规则，积分服务订阅积分变更事件，发放奖金到用户钱包。

4.3 倒计时同步与结果推送

// 客户端倒计时显示（React/Flutter/小程序通用）
// 关键：使用服务端截止时间戳 - 本地时间，不信任本地倒计时

class QuizTimer extends React.Component {
    state = { remaining: 10 }

    componentDidMount() {
        // 每100ms更新一次（精度够用，减少CPU消耗）
        this.interval = setInterval(() => {
            const { deadline, serverTime } = this.props
            const now = Date.now()
            // 网络延迟补偿：减去服务端到客户端的时间偏移
            const adjustedNow = now - (now - serverTime)
            const remaining = Math.max(0, Math.ceil((deadline - adjustedNow) / 1000))
            this.setState({ remaining })
        }, 100)
    }

    render() {
        const { remaining } = this.state
        return (
            

                
                    {remaining}
                
            
        )
    }
}

五、性能指标与成果

5.1 核心数据

5.2 活动数据

5.3 业务价值

• 拉新效率：每场活动新增注册用户30万+，ROI远超传统广告投放
• 用户体验：倒计时误差<50ms，所有用户感受到完全同步，无投诉"有人提前看到答案"
• 系统稳定性：5场活动全部稳定运行，零服务中断，零重大故障