每天一道面试题之架构篇｜低延迟实时排行榜系统架构设计

面试官直接问道："如果要设计一个支持百万用户实时竞技的游戏排行榜，如何保证低延迟和高并发？"

一、开篇：实时排行榜的核心挑战

想象一下：王者荣耀巅峰赛最后10秒，百万玩家同时刷新排名，系统如何保证实时性和准确性？

实时排行榜核心挑战：

• 极低延迟：95%请求响应时间<10ms
• 高并发读写：瞬时万级QPS处理能力
• 数据一致性：排名准确无跳变
• 弹性扩展：支持从千级到百万级用户平滑扩容

这就像奥运会百米决赛，计时系统必须精确到毫秒，排名结果必须实时准确

二、核心架构设计

2.1 技术选型与对比

各方案性能对比：

方案	响应延迟	并发能力	排名精度	适用场景
MySQL+实时计算	100ms+	千级QPS	精确	小型系统
Redis SortedSet	1-5ms	万级QPS	精确	中型排行榜
Redis+本地缓存	<1ms	十万级QPS	最终一致	大型实时榜

推荐架构：Redis SortedSet + 本地缓存 + 异步持久化

三、关键技术实现

3.1 Redis SortedSet核心操作

Spring Boot集成Redis排行榜：

@Service
@Slf4j
public class RankingService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private static final String RANKING_KEY = "game:ranking:season1";
    
    // 更新玩家分数
    public void updatePlayerScore(String playerId, double score) {
        // 使用管道提升性能
        redisTemplate.executePipelined((RedisCallback<Object>) connection -> {
            connection.zAdd(RANKING_KEY.getBytes(), score, playerId.getBytes());
            return null;
        });
        
        log.debug("更新玩家{}分数: {}", playerId, score);
    }
    
    // 获取玩家排名
    public Long getPlayerRank(String playerId) {
        // ZREVRANK获取排名（从0开始）
        Long rank = redisTemplate.opsForZSet().reverseRank(RANKING_KEY, playerId);
        return rank != null ? rank + 1 : null; // 转换为从1开始
    }
    
    // 获取排行榜前N名
    public Set<ZSetOperations.TypedTuple<Object>> getTopN(int n) {
        return redisTemplate.opsForZSet().reverseRangeWithScores(RANKING_KEY, 0, n - 1);
    }
    
    // 获取玩家周围排名（前后各5名）
    public Set<ZSetOperations.TypedTuple<Object>> getAroundPlayer(String playerId, int range) {
        Long rank = getPlayerRank(playerId);
        if (rank == null) return Collections.emptySet();
        
        long start = Math.max(0, rank - range - 1);
        long end = rank + range - 1;
        
        return redisTemplate.opsForZSet().reverseRangeWithScores(RANKING_KEY, start, end);
    }
}

3.2 多级缓存架构

本地缓存优化设计：

@Component
@Slf4j
public class RankingCacheManager {
    
    // 本地缓存top100排行榜
    private final Cache<String, List<RankingItem>> localCache = Caffeine.newBuilder()
        .maximumSize(10) // 缓存10个不同的排行榜
        .expireAfterWrite(100, TimeUnit.MILLISECONDS) // 100ms过期
        .refreshAfterWrite(50, TimeUnit.MILLISECONDS) // 50ms刷新
        .build();
    
    @Autowired
    private RankingService rankingService;
    
    // 获取带缓存的排行榜
    public List<RankingItem> getTopNWithCache(int n) {
        String cacheKey = "top_" + n;
        return localCache.get(cacheKey, key -> {
            Set<ZSetOperations.TypedTuple<Object>> topN = 
                rankingService.getTopN(n);
            return convertToRankingList(topN);
        });
    }
    
    // 异步刷新缓存
    @Scheduled(fixedRate = 50)
    public void refreshCache() {
        // 异步刷新前100名缓存
        CompletableFuture.runAsync(() -> {
            localCache.put("top_100", 
                convertToRankingList(rankingService.getTopN(100)));
        });
    }
    
    private List<RankingItem> convertToRankingList(Set<ZSetOperations.TypedTuple<Object>> set) {
        List<RankingItem> result = new ArrayList<>();
        long rank = 1;
        
        for (ZSetOperations.TypedTuple<Object> tuple : set) {
            result.add(new RankingItem(
                (String) tuple.getValue(),
                tuple.getScore(),
                rank++
            ));
        }
        
        return result;
    }
}

3.3 异步持久化与监控

RocketMQ异步数据持久化：

@Component
@Slf4j
public class RankingDataAsyncService {
    
    @Autowired
    private RocketMQTemplate rocketMQTemplate;
    
    // 异步记录分数变更
    @Async
    public void asyncRecordScoreChange(String playerId, double oldScore, 
                                     double newScore, String source) {
        ScoreChangeEvent event = new ScoreChangeEvent(playerId, oldScore, 
                                                    newScore, source, new Date());
        
        rocketMQTemplate.sendOneWay("ranking-score-topic", 
            MessageBuilder.withPayload(event).build());
    }
    
    // 批量更新数据库
    @RocketMQMessageListener(topic = "ranking-score-topic", 
                           consumerGroup = "ranking-persist-group")
    public void persistScoreChanges(List<ScoreChangeEvent> events) {
        if (events.isEmpty()) return;
        
        // 批量插入数据库
        try {
            rankingMapper.batchInsertScoreHistory(events);
            log.info("成功持久化{}条分数记录", events.size());
        } catch (Exception e) {
            log.error("分数记录持久化失败", e);
            // 加入重试队列
            events.forEach(event -> 
                rocketMQTemplate.sendOneWay("ranking-score-retry-topic", 
                    MessageBuilder.withPayload(event).build()));
        }
    }
}

四、高级特性实现

4.1 分数防刷与校验

基于滑动窗口的限流防护：

@Component
@Slf4j
public class ScoreAntiCheatService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    // 检查分数更新频率
    public boolean checkUpdateFrequency(String playerId, double newScore) {
        String key = "score_update:" + playerId;
        long now = System.currentTimeMillis();
        
        // 使用滑动窗口限制频率
        Long count = redisTemplate.opsForZSet().count(key, now - 60000, now);
        if (count != null && count >= 100) {
            log.warn("玩家{}分数更新过于频繁", playerId);
            return false;
        }
        
        // 记录本次更新
        redisTemplate.opsForZSet().add(key, String.valueOf(now), now);
        redisTemplate.expire(key, Duration.ofMinutes(2));
        
        return true;
    }
    
    // 分数变化合理性校验
    public boolean validateScoreChange(String playerId, double oldScore, 
                                      double newScore) {
        double maxIncrease = getMaxAllowedIncrease(playerId);
        
        if (newScore - oldScore > maxIncrease) {
            log.warn("玩家{}分数异常增长: {} -> {}", playerId, oldScore, newScore);
            return false;
        }
        
        return true;
    }
    
    private double getMaxAllowedIncrease(String playerId) {
        // 根据玩家等级、历史表现等动态计算最大允许增长
        return 1000.0; // 示例值
    }
}

4.2 实时监控与告警

排行榜健康度监控：

@Component
@Slf4j
public class RankingMonitorService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Scheduled(fixedRate = 30000)
    public void monitorRankingHealth() {
        // 监控Redis内存使用
        Long zsetSize = redisTemplate.opsForZSet().size(RANKING_KEY);
        Double memoryUsage = getRedisMemoryUsage();
        
        if (zsetSize != null && zsetSize > 1000000) {
            log.warn("排行榜数据量过大: {}", zsetSize);
            // 触发数据归档
            archiveOldData();
        }
        
        if (memoryUsage > 0.8) {
            log.error("Redis内存使用率过高: {}", memoryUsage);
            // 发送告警通知
            sendMemoryAlert(memoryUsage);
        }
    }
    
    // 性能监控端点
    @Endpoint(id = "ranking-stats")
    @Component
    public class RankingStatsEndpoint {
        
        @ReadOperation
        public Map<String, Object> rankingStats() {
            Map<String, Object> stats = new HashMap<>();
            stats.put("totalPlayers", 
                redisTemplate.opsForZSet().size(RANKING_KEY));
            stats.put("updateQps", getUpdateQps());
            stats.put("avgLatency", getAverageLatency());
            return stats;
        }
    }
}

五、完整架构示例

5.1 系统架构图

[游戏客户端] -> [API网关] -> [排行榜服务] -> [Redis集群]
    |              |             |            |
    v              v             v            v
[分数校验] <- [限流防护] <- [本地缓存] <- [异步持久化]
    |              |             |            |
    v              v             v            v
[监控告警] -> [数据归档] -> [MySQL集群] -> [数据分析]

5.2 配置优化

# application-ranking.yml
spring:
  redis:
    cluster:
      nodes: redis-cluster:6379
    timeout: 1000
    lettuce:
      pool:
        max-active: 1000
        max-wait: 10ms
        max-idle: 100

ranking:
  local-cache:
    enabled: true
    top-n: 1000
    expire-time: 100ms
  anti-cheat:
    enabled: true
    max-updates-per-minute: 100
    max-score-increase: 1000
  monitor:
    enabled: true
    check-interval: 30s
    memory-threshold: 0.8

六、面试陷阱与加分项

6.1 常见陷阱问题

问题1："Redis内存爆了怎么办？"

参考答案：

• 定期归档历史数据到MySQL
• 使用Redis集群分片存储
• 设置适当的数据过期策略
• 监控内存使用并设置自动告警

问题2："网络分区时排名不一致怎么处理？"

参考答案：

• 使用Redis集群的WAIT命令确保数据同步
• 客户端缓存降级方案
• 最终一致性+版本号控制

问题3："如何支持多种排序规则？"

参考答案：

• 使用多个SortedSet存储不同维度的排名
• 基于标签的分数设计（如：分数+时间戳）
• 实时计算综合排名

6.2 面试加分项

1. 业界最佳实践：

   • 腾讯游戏：Redis集群+自定义内存分配策略
   • 网易：多级缓存+动态扩容机制
   • 暴雪：分区排行榜+跨服排名合并

2. 高级特性：

   • 实时弹幕：排名变化实时通知
   • 赛季系统：自动赛季切换和数据重置
   • 数据分析：玩家行为深度分析

3. 性能优化：

   • 连接池优化：动态调整Redis连接数
   • 序列化优化：使用Protobuf减少网络传输
   • 批量处理：分数更新批量提交

七、总结与互动

排行榜设计哲学：Redis扛实时，缓存降延迟，异步保持久，监控稳运行——四位一体构建高性能排行榜系统

记住这个性能公式：Redis SortedSet + 本地缓存 + 异步持久化 + 实时监控 = 完美实时排行榜

---

思考题：在你的游戏项目中，排行榜最大的性能瓶颈是什么？欢迎在评论区分享优化经验！

关注我，每天搞懂一道面试题，助你轻松拿下Offer！