知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 50 - "三高"面试场景全解(高并发 / 高可用 / 高性能) > 导读:本文把后端面试里最常被追问的"三高"——高并发、高可用、高性能——拆成 12 个可落地的场景问答。读完你能:说清三者的关系与衡量指标、讲出每一类问题的核心机制、在具体数字面前(百万 QPS、99.99%、3000 万行深分页、2s → 50ms)给出方案取舍、参数与代码。适合准备中高级 Java 后端面试的同学,也适合需要把这些方案真正落到生产的工程师。建议先读第一节建立全局认知、第二节理解机制,再按需跳到第三节对应场景。 --- ## 一、先建立全局认知 ### Q:高并发、高可用、高性能分别指什么,它们之间是什么关系? **先给结论**:三者回答的是三个不同的问题——高并发问"同时来这么多请求,我扛不扛得住",高可用问"出故障了我还能不能提供服务",高性能问"单个请求我处理得够不够快"。它们是三件事,不能互相替代。 **一句话定义:** - **高并发(High Concurrency)**:系统在同一时刻承载大量并行请求的能力,衡量的是"单位时间能处理多少请求",常用 QPS/TPS、并发连接数描述。 - **高可用(High Availability)**:系统在部分组件或机房发生故障时,仍能持续对外提供服务的能力,衡量的是"不可用时间有多短、故障时丢不丢数据",常用可用性百分比、RTO/RPO 描述。 - **高性能(High Performance)**:单个请求处理得快、单位资源产出高,衡量的是"延迟多低、吞吐多高、资源多省",常用 RT/P99、吞吐量、CPU 与内存占用描述。 **它们之间的关系:** 1. **高性能是底座**。延迟低、单机吞吐高,才谈得上用更少的机器扛更高的并发;反过来,性能劣化往往在高并发下第一个暴露。 2. **高并发会放大一切问题**。原本低频的锁竞争、缓存击穿、GC 停顿,在百万 QPS 下都会被放大成故障。所以高并发场景里,性能优化和高可用手段通常是同时上的。 3. **高可用需要冗余,而冗余要付出代价**。多副本、多机房会带来数据一致性成本与机器成本;强一致手段(如 MySQL 半同步复制)能提高数据可靠性,却有约 20% 的性能损耗(详见第三节 Q5)。这就是典型的设计取舍。 4. **三者会互相冲突**。加缓存能提性能、降 DB 压力,却引入一致性风险(正确性问题);限流能保稳定(高可用),却会拒绝部分用户请求。架构师的工作是明确当前优先级,而不是要求三者同时最优。 > 记忆钩子:高并发是"量"的问题,高可用是"稳"的问题,高性能是"快"的问题。 ### Q:三者的常见指标(QPS、可用性、P99)怎么理解? **QPS / TPS**:QPS(Queries Per Second)指每秒查询数,TPS(Transactions Per Second)指每秒事务数,后者通常对应一次完整业务操作(如"下单"可能包含多条 SQL)。二者描述的是"处理能力"。 **并发数与 QPS 的换算**:稳态下满足利特尔法则(Little's Law)——**QPS ≈ 并发数 / 平均响应时间**。例如 200 个并发线程、平均 RT 50ms,理论 QPS ≈ 200 / 0.05 = 4000。这条公式解释了一个常见现象:RT 变长会直接拉低 QPS,即使线程数没变。 **可用性(Availability)**:全年可用时间占比,用"N 个 9"表示。它的感受不是线性的——从 3 个 9 到 4 个 9,允许的不可用时间会断崖式下降(完整对照表见第三节 Q5)。可用性越高,冗余与演练成本越高。 **P99 / P999(分位数)**:P99 = 99% 的请求耗时都小于该值。为什么盯 P99 而不是平均值?因为平均值会被大量快请求"稀释"。一个接口平均 50ms,但只要 1% 的请求耗时 5 秒,用户体验依然很差;而且这类长尾请求往往对应慢查询、锁等待、GC 停顿——正是故障的前兆。高并发下 P99 会被放大成"雪崩的起点",所以要单独监控。 **RTO / RPO**:RTO(Recovery Time Objective)是"故障后多久能恢复",RPO(Recovery Point Objective)是"故障会丢多少数据"。前者衡量恢复速度,后者衡量数据可靠性,做容灾方案时必须分开谈,见第三节 Q5。 ### Q:本篇覆盖哪些子场景? 本文按"高并发 / 高可用 / 高性能"三块组织,共 12 个场景。每个场景都会给出"场景描述 → 2~3 个方案(含 Java 代码/配置)→ 方案对比表 → 面试回答要点 → 高频追问": - **高并发**:① 百万 QPS 网关层设计;② 热点数据识别与处理;③ 分布式 ID 方案对比;④ 消息队列削峰填谷。 - **高可用**:⑤ 99.99% 可用系统设计;⑥ 熔断/降级/限流的区别与联动;⑦ 灰度发布与蓝绿部署;⑧ 监控告警体系搭建。 - **高性能**:⑨ 千万级数据分页优化;⑩ 接口 2s → 50ms 优化全过程;⑪ 全链路压测;⑫ JVM 调优实战。 最后第四节给出面试答题框架与一张高频追问速查表,并附自测题。 --- ## 二、理解核心机制 先建立机制层面的认知,再看第三节的具体场景,会比直接背方案更稳。本节只讲跨场景复用的"机制"与"取舍",具体实现放到第三节展开。 ### Q:高并发系统的核心机制有哪些? **核心其实一句话:把流量分散到更多资源上,并让每一层只做自己扛得住的事。** 具体机制: 1. **分层防御**:客户端 → CDN → Nginx → API 网关 → 业务服务,越靠前越便宜、越适合做"粗筛"。CDN 挡静态资源,Nginx 挡恶意 IP 与简单限流,网关按 route/service 维度限流,服务按接口/用户维度限流。 2. **限流算法**(要能互相对比): - **计数器 / 滑动窗口**:固定窗口实现简单,但有"临界突刺"问题(窗口边界处可能放过约 2 倍流量);滑动窗口把统计粒度细化,平滑度更好。 - **漏桶(Leaky Bucket)**:以恒定速率放行,多余请求排队或丢弃,输出速率绝对平滑,适合保护下游。 - **令牌桶(Token Bucket)**:以恒定速率发令牌,桶内可积累令牌,因此允许一定程度的突发。Nginx `limit_req` 属漏桶思路(`burst` 即桶容量,`nodelay` 决定突发是否立即放行)。 3. **削峰填谷**:用 MQ 做缓冲区,让下游按自身能力匀速消费;生产者侧限流优于让 MQ 无限堆积(堆积过多会导致消息延迟失控)。 4. **热点扩散与隔离**:多级缓存(本地 + 分布式)把热点数据推到离用户最近的地方;热点探测(如滑动窗口计数)后隔离到独立资源池,避免热点拖垮普通请求。 5. **异步化与无状态化**:写操作"接到就入队、立即返回受理结果",用 Netty/Reactor 的少量线程处理海量连接;服务无状态才能水平扩展。 **设计取舍**:限流放在越上游越省资源,但精度越差;放在越下游越精准,但下游已有压力。所以生产上通常是"每层都有限流,但阈值不同"的分层防御,而不是单点限流。详见第三节 Q1、Q2、Q4。 ### Q:高可用系统的核心机制有哪些? **核心一句话:用冗余消除单点,用自动故障转移缩短不可用时间,用隔离防止故障扩散。** 具体机制: 1. **冗余**:多副本、多实例、多机房。可用性的计算方式要注意——**串联**(缺一不可)时整体可用性是各组件之积 `A = A1 × A2 × ...`;**并联**(互为备份)时是 `1 - ∏(1 - Ai)`。这解释了为什么"多副本 + 自动摘除"能显著提升可用性。 2. **故障检测 + 自动故障转移**:健康检查(MySQL/Redis/MQ 探活)、注册中心摘除、数据源动态切换、DNS/GSLB 切换。 3. **熔断 / 降级 / 限流**(先各给一句定义): - **限流**:控制请求速率,超过阈值的直接拒绝——保护自己不被压垮。 - **熔断**:发现下游持续失败后,短时间内不再调用下游、直接快速失败——保护自己不被下游拖死,状态机为 CLOSED → OPEN → HALF_OPEN → CLOSED。 - **降级**:主动舍弃非核心功能,保住核心链路——牺牲功能换生存。 4. **隔离**:线程池隔离、信号量隔离、机房/集群隔离,避免一个依赖拖垮整个服务,防止"雪崩"沿调用链传导。 5. **容量与验证**:预留冗余容量、定期容灾演练、混沌工程(Chaos Engineering)主动注入故障来验证容灾能力。 **设计取舍**:隔离越细(如每个依赖独立线程池)越安全,但线程开销与上下文切换成本越高;Hystrix 用线程池隔离,Sentinel 用信号量隔离更轻量(见第三节 Q6)。详见第三节 Q5~Q8。 ### Q:高性能系统的核心机制有哪些? **核心一句话:减少不必要的计算与 IO,把能并行的并行,把能缓存的缓存。** 具体机制: 1. **缓存**:本地缓存(如 Caffeine,单次访问约微秒级)→ 分布式缓存(如 Redis)→ DB 兜底的多级结构;缓存要处理穿透、击穿、雪崩(随机 TTL、逻辑过期、互斥锁)。 2. **异步与并行**:串行调用改 `CompletableFuture` 并行,总耗时由最慢的一个决定(木桶效应);写操作异步化为"入队即返回"。 3. **索引与 SQL**:深分页慢的本质是"扫描并丢弃 OFFSET 之前的行 + 大量回表";优化方向是游标分页、用覆盖索引 + 子查询减少回表。 4. **批量与连接池**:N+1 查询合并为 `IN` 批量查询;连接池避免频繁建连开销。 5. **JVM / GC**:GC 的核心矛盾是"吞吐量 vs 延迟",没有两者都完美的 GC——G1 兼顾,ZGC 极致低延迟但吞吐略低。 6. **理论上限**:并行优化受 **Amdahl 定律**约束——加速比 = `1 / (串行比例 + 并行比例 / N)`,串行部分决定了天花板,这解释了"为什么加了并行还到不了目标"。 **设计取舍**:缓存收益最大但引入一致性风险;并行能压 RT,但会占用更多线程、增加下游瞬时压力。所以优化顺序通常是"先定位瓶颈(APM),再按收益从高到低做"。详见第三节 Q9~Q12。 --- ## 三、放进真实场景 下面把 12 个场景逐条拆成问答。每个问答都保留原文的方案、参数、代码、表格与追问;排版上只做"问什么、答什么"的重组。 ### 高并发(High Concurrency) #### Q1:如何设计一个支撑百万 QPS 的网关层? **场景描述** 某大促活动期间,瞬间峰值流量达到 100 万 QPS。所有请求先打到入口网关层,如果网关扛不住,后面的服务再强也没用。 ``` 客户端 → CDN → Nginx 反向代理 → API 网关(Spring Cloud Gateway/Zuul) → 业务服务 ↑ 第一层流量过滤:静态资源直接返回(不再穿透到后端) ``` **方案一:分层限流(Nginx → 网关 → 服务)**  *图:Nginx、网关、业务服务三层逐级限流* ``` ┌─────────────────────────────────────────────────────┐ │ Nginx 层(总入口) │ │ limit_req_zone $binary_remote_addr zone=one:10m rate=100r/s; │ │ 优势:C 语言实现,单机可达 10W+ QPS,挡掉 90% 恶意流量 │ └─────────────┬───────────────────────────────────────┘ │ ┌─────────────▼───────────────────────────────────────┐ │ 网关层(Spring Cloud Gateway) │ │ 基于 Sentinel 网关流控,按 route/service 维度限流 │ │ 优势:Java 生态集成方便,支持动态规则调整 │ └─────────────┬───────────────────────────────────────┘ │ ┌─────────────▼───────────────────────────────────────┐ │ 业务服务层 │ │ @SentinelResource 注解,按接口/用户维度限流 │ │ 优势:最细粒度控制,避免单个接口拖垮整个服务 │ └─────────────────────────────────────────────────────┘ ```  [编辑 Excalidraw 源图](/images/java-interview-copy/business-scenario/50-three-high-scenarios-three-high-high-concurrency-overview-diagram.excalidraw) **Nginx 层配置:** ```nginx # nginx.conf http { # 定义限流规则:单 IP 每秒 100 个请求 limit_req_zone $binary_remote_addr zone=api_limit:10m rate=100r/s; # 连接数限制 limit_conn_zone $binary_remote_addr zone=addr:10m; server { listen 80; # 静态资源 —— 直接返回,不穿透到后端 location ~* \.(html|css|js|png|jpg|gif|ico|svg)$ { root /data/static; expires 7d; add_header Cache-Control "public, immutable"; } # 动态接口 —— 限流后转发到网关 location /api/ { limit_req zone=api_limit burst=50 nodelay; limit_conn addr 10; proxy_pass http://gateway-cluster; } } } ``` **网关层 Sentinel 配置:** ```java @Configuration public class GatewaySentinelConfig { @PostConstruct public void initRules() { // 按 route 限流 —— 秒杀接口每分钟最多 50000 次 initGatewayRules(); // 系统自适应限流 initSystemRules(); } private void initGatewayRules() { Set<GatewayFlowRule> rules = new HashSet<>(); // 秒杀路由:每秒 5000 QPS rules.add(new GatewayFlowRule("seckill-route") .setCount(5000) .setIntervalSec(1)); // 普通商品路由:每秒 20000 QPS rules.add(new GatewayFlowRule("product-route") .setCount(20000) .setIntervalSec(1)); GatewayRuleManager.loadRules(rules); } private void initSystemRules() { // 入口 QPS 超过 80000 就触发系统保护 List<SystemRule> rules = new ArrayList<>(); SystemRule rule = new SystemRule(); rule.setHighestSystemLoad(16.0); // CPU LOAD > 16 触发 rule.setAvgRt(200); // 平均 RT > 200ms 触发 rule.setQps(80000); // 入口 QPS > 80000 触发 rule.setMaxThread(500); // 并发线程 > 500 触发 rules.add(rule); SystemRuleManager.loadRules(rules); } } ``` **方案二:动静分离 + CDN + 异步化**  *图:CDN 到 Netty 的动静分离处理链路* ``` ┌─────────────┐ │ CDN │ ← 静态资源(图片/CSS/JS)命中率 > 95% └──────┬──────┘ │ Cache Miss ┌──────▼──────┐ │ Nginx │ ← 动静分离 │ /static/* │ → 直接返回 │ /api/* │ → 转发网关 └──────┬──────┘ │ (只有动态请求) ┌──────▼──────┐ │ Gateway │ ← 异步化:请求进队列 │ + MQ │ 立即返回受理结果 └──────┬──────┘ │ ┌──────▼──────┐ │ Event Loop │ ← Netty 线程模型 │ Reactor │ 少量线程处理海量连接 └─────────────┘ ``` ```java // 异步化处理:网关收到请求后入队立即返回 @RestController public class AsyncOrderController { @Autowired private KafkaTemplate<String, String> kafkaTemplate; @PostMapping("/api/order/create") public Mono<ApiResponse> createOrder(@RequestBody OrderRequest req) { String requestId = SnowflakeIdGenerator.nextId(); String message = JSON.toJSONString(new OrderEvent(requestId, req)); // 发 MQ 异步处理,立即返回受理结果 return Mono.fromFuture( kafkaTemplate.send("order-create-topic", message) .completable() ).map(result -> ApiResponse.accepted(requestId, "已受理,请轮询结果")); } } ``` **方案对比** | 方案 | QPS 上限 | 实现复杂度 | 适用场景 | |------|----------|-----------|---------| | 分层限流 | ~10万/单 Nginx | 低 | 流量整形,防突发 | | 动静分离 + CDN | 百万级 | 中 | 静态资源占比高的场景 | | 异步化 + MQ | 百万级 | 高 | 写多读少,允许最终一致 | **面试回答要点** 1. 先说"分层防御"思想:CDN → Nginx → 网关 → 服务,每一层都有独立的限流和降级策略 2. 强调 Nginx 层能挡掉 90% 的无效流量(静态资源 + 恶意 IP + 简单限流) 3. 异步化是关键——不要同步阻塞等待写数据库,接到请求就入队返回 4. 加分项:提到 Netty/Reactor 模型的少量线程处理海量连接 **追问** **Q:100 万 QPS 单靠一台 Nginx 能扛住吗?** A:单台 Nginx 极限约 10~15 万 QPS。需要配合 LVS/F5 四层负载均衡做水平扩展:LVS → 多台 Nginx → 网关集群。 **Q:异步化后用户怎么知道结果?** A:三种方式:① 轮询(前端定时查结果接口);② WebSocket 推送;③ 客户端收到受理凭证后,等 MQ 消费完回调通知。 > 架构师视角:分层限流的代价是"规则要维护四份、口径要对齐"——Nginx 是 IP 维度、网关是路由维度、服务是接口/用户维度,一旦某层阈值配错,整体防护就会出现短板。所以生产上要么用配置中心统一管理(如 Sentinel 动态规则),要么把关键阈值纳入发布卡点。异步化的代价是"从同步强一致变成最终一致",只适合允许最终一致的写场景(下单、发券),不适合要求立即读到结果的查询。 --- #### Q2:热点数据如何识别与处理? **场景描述** 微博热搜榜,某个明星爆出大瓜,相关微博 10 秒钟内被访问 500 万次。热点 Key 的 QPS 是普通 Key 的 1000 倍以上,如果不做特殊处理: ``` Redis 单节点:10 万 QPS / 台 热点 Key 来了 50 万 QPS → Redis 被打爆 → 缓存穿透到 DB → DB 也打爆 → 雪崩 ``` **方案一:热点发现 —— 滑动窗口计数** ```java @Component public class HotKeyDetector { // Key → 滑动窗口内的访问次数 private final ConcurrentHashMap<String, SlidingWindowCounter> counters = new ConcurrentHashMap<>(); // 耗时较长的计算使用虚拟线程,不阻塞主线程 private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); private static final int WINDOW_SECONDS = 10; private static final int HOT_THRESHOLD = 1000; // 10 秒内访问超过 1000 次 private static final int CLEANUP_THRESHOLD_MIN = 10; @PostConstruct public void startCleanupTask() { // 定期清理超过 10 分钟未访问的 Key,防止内存泄漏 scheduler.scheduleAtFixedRate(this::cleanupExpiredKeys, 1, 1, TimeUnit.MINUTES); } public boolean isHot(String key) { counters.computeIfAbsent(key, k -> new SlidingWindowCounter(WINDOW_SECONDS)); SlidingWindowCounter counter = counters.get(key); counter.increment(); return counter.getCount() >= HOT_THRESHOLD; } // 滑动窗口计数器实现 static class SlidingWindowCounter { private final int windowSeconds; // 每 1 秒一个桶 private final ConcurrentSkipListMap<Long, AtomicInteger> buckets = new ConcurrentSkipListMap<>(); SlidingWindowCounter(int windowSeconds) { this.windowSeconds = windowSeconds; } void increment() { long bucketKey = System.currentTimeMillis() / 1000; buckets.computeIfAbsent(bucketKey, k -> new AtomicInteger()).incrementAndGet(); } int getCount() { long now = System.currentTimeMillis() / 1000; long threshold = now - windowSeconds; int total = 0; for (Map.Entry<Long, AtomicInteger> entry : buckets.entrySet()) { if (entry.getKey() >= threshold) { total += entry.getValue().get(); } } return total; } } private void cleanupExpiredKeys() { long threshold = System.currentTimeMillis() / 1000 - CLEANUP_THRESHOLD_MIN * 60; counters.forEach((key, counter) -> { // 只保留最近 10 分钟有数据的桶 counter.buckets.keySet().removeIf(bucketKey -> bucketKey < threshold); }); counters.entrySet().removeIf(entry -> entry.getValue().buckets.isEmpty()); } public Set<String> getHotKeys() { return counters.entrySet().stream() .filter(e -> e.getValue().getCount() >= HOT_THRESHOLD) .map(Map.Entry::getKey) .collect(Collectors.toSet()); } } ``` **方案二:多级缓存 + 热点隔离**  *图:本地缓存、Redis、数据库三级回源查询* ``` ┌────────────────┐ 请求 ──────────→│ 本地缓存(Caffeine)│ ← 热点 Key 缓存到应用 JVM 内 │ 命中率 > 95% │ 单次访问 ~1μs └────────┬───────┘ │ 未命中 ┌────────▼───────┐ │ Redis 集群 │ ← 普通 Key 走 Redis │ 命中率 ~4% │ └────────┬───────┘ │ 未命中 ┌────────▼───────┐ │ 数据库 │ ← 兜底 └────────────────┘ ``` ```java @Component public class MultiLevelCacheService { // 本地缓存:热点数据,最大 10000 条,5 秒过期 private final Cache<String, Object> localCache = Caffeine.newBuilder() .maximumSize(10_000) .expireAfterWrite(5, TimeUnit.SECONDS) .recordStats() .build(); @Autowired private HotKeyDetector hotKeyDetector; @Autowired private StringRedisTemplate redisTemplate; @Autowired private ProductMapper productMapper; public Product getProduct(String productId) { // 1. 先查本地缓存 Product cached = (Product) localCache.getIfPresent(productId); if (cached != null) { return cached; } // 2. 再查 Redis String redisKey = "product:" + productId; String json = redisTemplate.opsForValue().get(redisKey); if (json != null) { Product product = JSON.parseObject(json, Product.class); // 3. 如果是热点 Key,回种到本地缓存 if (hotKeyDetector.isHot(redisKey)) { localCache.put(productId, product); } return product; } // 4. 最后查 DB Product product = productMapper.selectById(productId); if (product != null) { redisTemplate.opsForValue().set(redisKey, JSON.toJSONString(product), 60 + ThreadLocalRandom.current().nextInt(30), TimeUnit.SECONDS); } return product; } } ``` **方案三:热点隔离 —— 独立资源池** ``` 正常 Key → Redis 集群 A(普通资源,10 个节点) 热点 Key → Redis 集群 B(高配机器,独立部署) 热点发现 → 自动将热点 Key 迁移到独立集群 → 避免热点影响普通请求 ``` ```java @Component public class HotKeyRouter { @Autowired @Qualifier("normalRedisTemplate") private StringRedisTemplate normalRedis; @Autowired @Qualifier("hotRedisTemplate") private StringRedisTemplate hotRedis; @Autowired private HotKeyDetector detector; private final Set<String> isolatedKeys = ConcurrentHashMap.newKeySet(); public StringRedisTemplate route(String key) { // 已经被隔离的热点 Key if (isolatedKeys.contains(key)) { return hotRedis; } // 新发现的热点 Key → 自动隔离 if (detector.isHot(key)) { isolatedKeys.add(key); // 把数据从普通 Redis 迁移到热点 Redis String value = normalRedis.opsForValue().get(key); if (value != null) { hotRedis.opsForValue().set(key, value, 60, TimeUnit.SECONDS); } return hotRedis; } return normalRedis; } // 热点 Key 降温后从隔离集群移除 @Scheduled(fixedDelay = 30_000) public void cooldownCheck() { isolatedKeys.removeIf(key -> !detector.isHot(key)); } } ``` **方案对比** | 方案 | 热点命中延迟 | 资源占用 | 实现复杂度 | 适用场景 | |------|-------------|---------|-----------|---------| | 滑动窗口发现 | ~10 秒 | 低(内存) | 中 | 所有场景,前提是精度要求不高 | | 多级缓存 | ~1μs(本地命中) | 中(JVM 堆) | 中 | 读多写少的热点数据 | | 热点隔离 | ~1ms(Redis) | 高(独立集群) | 高 | 超高流量热点,舍得堆硬件 | **面试回答要点** 1. 先说问题本质:热点 Key 会打爆单 Redis 节点(热 Key 问题)或单应用实例(热点流量集中) 2. 核心思路是"多级缓存 + 热点隔离",把热点数据推到离用户最近的地方(本地缓存) 3. 热点发现可以用滑动窗口计数,也可以直接用京东开源的 HotKey 组件 4. 加分项:提到本地缓存的一致性处理(推模式:热点变化时广播通知所有实例刷新本地缓存) **追问** **Q:热点 Key 突然过期导致缓存击穿怎么办?** A:两个手段:① 热点 Key 设置随机过期时间 + 逻辑过期(永不过期,由后台线程异步刷新);② 使用互斥锁(`SETNX`)保证只有一个线程回源查 DB 重建缓存。 **Q:本地缓存和 Redis 缓存数据不一致怎么办?** A:① 本地缓存 TTL 设短(3~5 秒),最终一致性容忍短暂不一致;② 强一致场景用消息广播(MQ/Redis PubSub)通知所有节点清除本地缓存。 > 架构师视角:热点探测本质上是个"精度 vs 成本"的取舍——滑动窗口发现延迟约 10 秒、几乎零成本,但热点已经打进来 10 秒了;热点隔离最精准,但要多养一套集群。生产上常见的是"先多级缓存兜住、再异步隔离",而不是一上来就上独立集群。另一个坑:本地缓存把数据放进了 JVM 堆,热点 Key 数量不可控时可能把堆撑爆,所以 `maximumSize` 必须设上限。 --- #### Q3:分布式 ID 生成方案有哪些,怎么选? **场景描述** 订单系统拆成 20 个服务实例,每天生成 5000 万条订单记录。需要一个全局唯一的订单 ID,而且要求: - 全局唯一(不能有重复) - 趋势递增(方便 MySQL 索引) - 高性能(单机 1 万 TPS 以上) - 高可用(不能有单点故障) **方案一:雪花算法(Snowflake)**  *图:Snowflake 64 位 ID 字段划分与理论 QPS* ``` 64 位长整型: ┌─┬─────────────────────────────────────┬───────────┬──────────────┐ │0│ 41 位时间戳(毫秒) │10 位机器ID │12 位序列号 │ └─┴─────────────────────────────────────┴───────────┴──────────────┘ 时间戳:当前时间 - 自定义起始时间,可用 69 年 机器ID:最多 1024 个节点(可拆成 5 位数据中心 + 5 位机器) 序列号:同一毫秒内最多生成 4096 个 ID 理论 QPS:4096 × 1000 = 409.6 万 / 秒 / 机器 ``` ```java public class SnowflakeIdGenerator { // 起始时间戳(2024-01-01 00:00:00) private static final long START_TIMESTAMP = 1704067200000L; private static final long WORKER_ID_BITS = 10L; private static final long SEQUENCE_BITS = 12L; private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS); // 1023 private static final long MAX_SEQUENCE = ~(-1L << SEQUENCE_BITS); // 4095 private static final long TIMESTAMP_SHIFT = WORKER_ID_BITS + SEQUENCE_BITS; private static final long WORKER_ID_SHIFT = SEQUENCE_BITS; private final long workerId; private long sequence = 0L; private long lastTimestamp = -1L; public SnowflakeIdGenerator(long workerId) { if (workerId > MAX_WORKER_ID || workerId < 0) { throw new IllegalArgumentException( "workerId must be 0~" + MAX_WORKER_ID); } this.workerId = workerId; } public synchronized long nextId() { long timestamp = System.currentTimeMillis(); // 时钟回拨检测 if (timestamp < lastTimestamp) { long offset = lastTimestamp - timestamp; if (offset <= 5) { // 回拨 5ms 以内,等待追赶 try { Thread.sleep(offset + 1); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } timestamp = System.currentTimeMillis(); } else { throw new RuntimeException( "Clock moved backwards. Refusing to generate id for " + offset + " milliseconds"); } } if (timestamp == lastTimestamp) { sequence = (sequence + 1) & MAX_SEQUENCE; if (sequence == 0) { // 当前毫秒序列号用完,等到下一毫秒 timestamp = waitNextMillisecond(lastTimestamp); } } else { sequence = 0L; } lastTimestamp = timestamp; return ((timestamp - START_TIMESTAMP) << TIMESTAMP_SHIFT) | (workerId << WORKER_ID_SHIFT) | sequence; } private long waitNextMillisecond(long lastTimestamp) { long timestamp = System.currentTimeMillis(); while (timestamp <= lastTimestamp) { timestamp = System.currentTimeMillis(); } return timestamp; } } ``` **方案二:号段模式(美团 Leaf)** ``` 原理:从数据库一次取一个"号段"(如 1000 个 ID),在内存中分配 第一次: 取号段 [1, 1000] → 内存发放 1, 2, 3, ..., 1000 第二次: 取号段 [1001, 2000] → 内存发放 1001, 1002, ... 第三次: 取号段 [2001, 3000] → 内存发放 2001, 2002, ... 优势:不需要和数据库频繁交互,内存中分配 ID 极快 双 Buffer 机制:当前号段用完 10% 时异步加载下一个号段,无缝切换 ``` ```sql -- 号段表结构 CREATE TABLE leaf_alloc ( biz_tag VARCHAR(128) NOT NULL DEFAULT '' COMMENT '业务标识', max_id BIGINT NOT NULL DEFAULT 1 COMMENT '当前已分配的最大 ID', step INT NOT NULL DEFAULT 1000 COMMENT '号段步长', update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (biz_tag) ) ENGINE=InnoDB; ``` ```java @Component public class SegmentIdGenerator { // 双 Buffer private volatile Segment current; private volatile Segment next; @Autowired private LeafAllocMapper leafAllocMapper; private final Object lock = new Object(); private static final double LOADING_FACTOR = 0.1; // 剩余 10% 时预加载 public synchronized long nextId(String bizTag) { if (current == null) { current = fetchSegment(bizTag); next = fetchSegment(bizTag); // 提前加载备胎 } long id = current.getAndIncrement(); // 当前号段即将用完 → 切换 next,并异步预加载下一个 if (current.getIdle() < current.getStep() * LOADING_FACTOR && next != null) { synchronized (lock) { if (current.getIdle() < current.getStep() * LOADING_FACTOR && next != null) { current = next; next = null; // 虚拟线程异步加载下一个号段 Thread.ofVirtual().start(() -> { if (this.next == null) { this.next = fetchSegment(bizTag); } }); } } } return id; } private Segment fetchSegment(String bizTag) { // UPDATE leaf_alloc SET max_id = max_id + step WHERE biz_tag = ? // 然后返回 [old_max_id + 1, new_max_id] 作为号段 LeafAlloc updated = leafAllocMapper.updateAndGet(bizTag); return new Segment(updated.getMaxId() - updated.getStep() + 1, updated.getMaxId()); } static class Segment { private final AtomicLong value; private final long max; Segment(long min, long max) { this.value = new AtomicLong(min); this.max = max; } long getAndIncrement() { long v = value.getAndIncrement(); if (v > max) { throw new RuntimeException("号段耗尽"); } return v; } long getIdle() { return max - value.get() + 1; } long getStep() { return max - value.get(); } } } ``` **方案三:Redis 自增** ```java @Component public class RedisIdGenerator { @Autowired private StringRedisTemplate redisTemplate; private static final String ID_KEY_PREFIX = "order:id:"; private static final int CACHE_SIZE = 1000; // 本地缓存一批 ID,减少 Redis 访问 private final Map<String, Queue<Long>> localCache = new ConcurrentHashMap<>(); public long nextId(String bizTag) { Queue<Long> queue = localCache.computeIfAbsent(bizTag, k -> new ConcurrentLinkedQueue<>()); Long id = queue.poll(); if (id != null) { return id; } // 缓存耗尽,从 Redis 批量获取 Long end = redisTemplate.opsForValue() .increment(ID_KEY_PREFIX + bizTag, CACHE_SIZE); long start = end - CACHE_SIZE + 1; for (long i = start; i <= end; i++) { queue.offer(i); } return queue.poll(); } } ``` **方案对比** | 方案 | 性能 | 趋势递增 | 依赖 | 缺点 | |------|------|---------|------|------| | 雪花算法 | 极高(409W/s/机) | 是 | 无 | 时钟回拨问题,机器 ID 需手动分配 | | 号段模式 | 极高(内存分配) | 是 | 数据库 | 需维护号段表,依赖 DB | | Redis 自增 | 高(~10W/s) | 是 | Redis | Redis 挂了发不出 ID | | UUID | 极高 | **否** | 无 | 字符串存储大、无序导致页分裂 | **面试回答要点** 1. 先说"为什么不用自增 ID"(分库分表后冲突、扩容迁移困难) 2. 推荐雪花算法(无外部依赖、性能极高)或美团 Leaf 号段模式(团队有数据库运维能力时) 3. 雪花算法的坑:时钟回拨 → 解决方式:等待重试 / 用 NTP 保证时间同步 / 抛异常 4. 加分项:提到美团的 Leaf-snowflake 方案(用 ZooKeeper 持久顺序节点注册 workerId,不用手动分配) **追问** **Q:雪花算法时间回拨怎么处理?** A:① 回拨 5ms 以内 → sleep 等待追上;② 回拨超过 5ms → 抛异常告警,人工介入;③ 生产环境用百度 UidGenerator(基于雪花优化,借用未来时间补偿回拨)。 **Q:用了雪花算法,为什么订单号还是递增的但是不连续?** A:雪花算法保证趋势递增(后面的 ID > 前面的 ID),但不保证严格连续递增(同一毫秒内序列号递增,跨毫秒后序列号归零)。这在 B+Tree 索引上已经足够好了——不会造成页分裂。 > 架构师视角:选型的本质是"你愿意依赖什么"。雪花不依赖任何外部组件,但要自己解决机器 ID 分配与时钟回拨;号段模式依赖 DB,换来的是 ID 可读、绝对单调递增;Redis 自增实现最简单,但引入了一个新的强依赖单点。生产上如果已有 ZooKeeper/etcd,Leaf-snowflake 的自动注册 workerId 能省掉运维心智。注意 41 位时间戳"可用 69 年"是从自定义 epoch 起算的近似值,具体取决于起始时间戳设置。 --- #### Q4:消息队列如何削峰填谷? **场景描述** 双 11 零点,1 秒内涌入 50 万笔下单请求,后台服务只能处理 5 万 TPS。直接调用会让服务线程池爆炸、数据库连接池耗尽,最终 OOM 崩溃。 ``` 瞬间请求:████████████████████████████████ 50W/s 服务能力:█████ 5W/s 如果不削峰: 线程池 500 线程全满 → 请求堆积 → 超时 → 数据库连接池 200 连接全满 → 新请求拿不到连接 → → 雪崩 ``` **方案一:生产者限流 + MQ 缓冲**  *图:Sentinel 限流 5W/s 与 MQ 堆积削峰* ``` ┌─────────────┐ 50W/s 请求 ──→ │ Sentinel │ ← 生产者限流:只放 5W/s 进 MQ │ 限流 5W/s │ └──────┬──────┘ ↓ 5W/s ┌─────────────┐ │ RocketMQ │ ← 消息堆积(削峰) │ 堆积 45W │ └──────┬──────┘ ↓ 5W/s ┌─────────────┐ │ 消费者 │ ← 按自身能力匀速消费 │ 匀速处理 │ └─────────────┘ ``` ```java // === 生产者:Sentinel 限流 === @Service public class OrderProducer { @Autowired private RocketMQTemplate rocketMQTemplate; @SentinelResource(value = "order-create", blockHandler = "orderBlockHandler") public void sendOrderMessage(OrderRequest request) { String orderJson = JSON.toJSONString(request); rocketMQTemplate.syncSend("order-topic", MessageBuilder.withPayload(orderJson).build(), 3000 // 3000ms 超时 ); } // 限流后被拒绝,返回"系统繁忙" public void orderBlockHandler(OrderRequest request, BlockException e) { throw new BizException(429, "系统繁忙,请稍后再试"); } } ``` **方案二:消费者批量拉取 + 背压机制** ```java // === 消费者:批量拉取 + 背压 === @Component @RocketMQMessageListener( topic = "order-topic", consumerGroup = "order-consumer-group", consumeMode = ConsumeMode.CONCURRENTLY // 并发消费 ) public class OrderConsumer implements RocketMQListener<String> { // 背压信号量:最多同时处理 200 个消息 private final Semaphore backpressure = new Semaphore(200); // 线程池保护 private final ThreadPoolExecutor executor = new ThreadPoolExecutor( 50, 100, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(2000), new ThreadPoolExecutor.CallerRunsPolicy() // 队列满了让调用线程执行=天然背压 ); @Override public void onMessage(String message) { try { // 获取背压许可(超时 5 秒拿不到就拒绝) if (!backpressure.tryAcquire(5, TimeUnit.SECONDS)) { // 超时→返回 CONSUME_LATER → RocketMQ 会重试 throw new RuntimeException("系统繁忙,稍后重试"); } executor.submit(() -> { try { processOrder(message); } finally { backpressure.release(); } }); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RuntimeException(e); } } private void processOrder(String message) { // 实际业务逻辑:扣库存、创建订单、扣款... } } ``` **方案三:分层削峰(网关 + MQ + 消费者三级)**  *图:三层限流与消费者动态扩缩容方案* ``` ┌──────────────────────────────┐ 峰值 50W/s ──────→ │ L1: 网关层令牌桶 限流至 20W/s │ └──────────────┬───────────────┘ ↓ 20W/s ┌──────────────▼───────────────┐ │ L2: 业务层限流 + RocketMQ 堆积 │ │ 入 MQ 速度: 10W/s │ │ MQ 堆积: 10W~40W │ └──────────────┬───────────────┘ ↓ ┌──────────────▼───────────────┐ │ L3: 消费者动态扩缩容 │ │ 基础 50 台 → 触发扩容到 150 台 │ │ MQ 堆积 < 1W 后缩回 │ └──────────────────────────────┘ ``` ```java // 基于 MQ 堆积量动态扩缩消费者(Kubernetes HPA 伪代码) @Component public class ConsumerAutoScaler { @Autowired private DefaultMQPullConsumer consumer; @Scheduled(fixedDelay = 30_000) public void checkAndScale() { long diff = consumer.fetchConsumeOffset("order-topic", concurrency) - consumer.maxOffset("order-topic"); if (diff > 50_000) { // 堆积 > 5W → 扩容消费者 kubernetesApi.scaleDeployment("order-consumer", 150); log.warn("触发扩容: 当前堆积 {} 条", diff); } else if (diff < 10_000) { // 堆积 < 1W → 缩容 kubernetesApi.scaleDeployment("order-consumer", 50); log.info("触发缩容: 当前堆积 {} 条", diff); } } } ``` **方案对比** | 方案 | 削峰能力 | 堆积风险 | 实现复杂度 | 适用场景 | |------|---------|---------|-----------|---------| | 生产者限流 | 强(源头控制) | 低 | 低 | 普通峰值场景 | | 消费者背压 | 中(靠信号量) | 中 | 中 | 下游处理能力波动大 | | 分层削峰+动态扩缩 | 最强 | 高(需监控) | 高 | 大促级别峰值 | **面试回答要点** 1. 先说削峰填谷的原理:MQ 充当缓冲区,让下游按自己的节奏消费 2. 要点出"生产者限流"比"MQ 无限堆积"更优——MQ 堆积太多会导致消息延迟过大 3. 背压机制很重要:消费者不能"来多少吃多少",要根据自身能力控制消费速度 4. 加分项:提到 Kafka 的消费者组 Rebalance 对削峰的影响(Rebalance 期间会停止消费!) **追问** **Q:MQ 堆积到几百万条怎么办?** A:① 紧急扩容消费者数量;② 新建 Topic 把积压消息转存,原 Topic 只处理新消息;③ 积压消息批量聚合处理(如把 100 条合并成 1 条);④ 不太重要的消息直接跳过(如已过期的秒杀消息)。 **Q:消费者处理慢导致 MQ 一直重试怎么办?** A:① 设置合理的消费超时时间 + 最大重试次数;② 超过重试次数的消息进入死信队列,人工处理;③ 排查消费者慢的原因(DB 慢查询?外部调用超时?加缓存!异步化!)。 > 架构师视角:削峰不是"把请求全接下来",而是"决定拒绝谁"。生产者限流虽然简单,但被拒的用户拿到的是"系统繁忙";而无限堆积看似友好,代价是用户等几分钟甚至十几分钟才拿到结果,还可能因为消息过期而丢单。所以大促场景往往是"入口限流 + 排队令牌"组合:先到的人拿到受理凭证,超出容量的直接快速失败,比让所有人一起超时要好。另一个容易忽略的点是消息过期时间——MQ 堆积超过消息 TTL 会直接丢消息,这个参数必须和峰值时长一起评估。 --- ### 高可用(High Availability) #### Q5:如何设计一个 99.99% 可用的系统? **场景描述** 99.99%(即"四个九")意味着全年不可用时间不超过 52.56 分钟。对于一个日活千万的电商平台,每多宕机 1 分钟,直接损失几十万。 ``` 可用性对照表: 99% = 2个9 → 全年不可用 3.65 天 99.9% = 3个9 → 全年不可用 8.76 小时 99.99% = 4个9 → 全年不可用 52.56 分钟 99.999% = 5个9 → 全年不可用 5.26 分钟 ``` **方案一:同城双活**  *图:GSLB 智能解析分流到主备双机房* ``` ┌──────────┐ ┌──────────┐ │ 用户 │ │ 用户 │ └─────┬────┘ └─────┬────┘ │ │ ┌─────▼─────────────────────▼─────┐ │ DNS / GSLB 智能解析 │ │ 根据用户地域 + 机房健康度分流 │ └─────┬─────────────────────┬─────┘ │ │ ┌────────▼────────┐ ┌───────▼─────────┐ │ 机房 A(主) │ │ 机房 B(备) │ │ 承担 60% 流量 │ │ 承担 40% 流量 │ │ MySQL 主库 │◄──│ MySQL 从库 │ │ Redis 主 │ │ Redis 从 │ │ MQ 集群 │ │ MQ 集群 │ └──────────────────┘ └──────────────────┘ │延迟 < 2ms│ └──────────┘ ``` ```java // 多数据源动态路由 @Component public class DataSourceRouter { private volatile DataSourceEnum currentDataSource = DataSourceEnum.MASTER; @PostConstruct public void initHealthCheck() { // 每 5 秒检测机房健康状态 Executors.newSingleThreadScheduledExecutor() .scheduleAtFixedRate(this::healthCheck, 0, 5, TimeUnit.SECONDS); } private void healthCheck() { // 1. 检查当前机房各组件健康度 boolean mysqlOk = checkMySQL(); boolean redisOk = checkRedis(); boolean mqOk = checkMQ(); if (!mysqlOk || !redisOk || !mqOk) { // 2. 任何组件异常 → 切换机房 switchDataSource(); // 3. 告警 alertService.send("机房 A 异常,已切换至机房 B"); } } private void switchDataSource() { if (currentDataSource == DataSourceEnum.MASTER) { currentDataSource = DataSourceEnum.STANDBY; // 动态切换数据源(使用 AbstractRoutingDataSource) DynamicDataSourceContextHolder.setDataSource(DataSourceEnum.STANDBY); } } private boolean checkMySQL() { try (Connection conn = dataSource.getConnection()) { return conn.isValid(3); // 3 秒超时 } catch (Exception e) { return false; } } private boolean checkRedis() { try { return "PONG".equals(redisTemplate.getConnectionFactory() .getConnection().ping()); } catch (Exception e) { return false; } } private boolean checkMQ() { // 检查 MQ NameServer 连通性 try { rocketMQTemplate.getProducer().getDefaultMQProducerImpl() .getmQClientFactory().getMQClientAPIImpl() .getClusterInfo(3000); return true; } catch (Exception e) { return false; } } } ``` **方案二:两地三中心(金融级)**  *图:同城双活加异地灾备的两地三中心* ``` ┌──────────────────────────────────────────────────────────────┐ │ 同城双活 │ │ ┌──────────────┐ ┌──────────────┐ │ │ │ 机房 A(主) │ ← 数据同步 → │ 机房 B(备) │ │ │ └──────────────┘ └──────────────┘ │ │ │ │ │ │ └────────── 异步复制 ──────────┘ │ │ │ │ └──────────────────────────┼───────────────────────────────────┘ │ ┌────────▼────────┐ │ 异地灾备中心 │ ← 距离 > 1000km │ 机房 C(冷备) │ 数据延迟 1~5 秒 └─────────────────┘ 同城全挂时才启用 ```  *图:四类灾难场景与对应应对策略* ``` 灾难场景分析: ┌────────────────┬───────────────────────────────────┐ │ 故障级别 │ 应对策略 │ ├────────────────┼───────────────────────────────────┤ │ 单机故障 │ 自动摘除 + 新实例自动补充 │ │ 单机房网络故障 │ 自动切换到同城另一机房(同城双活) │ │ 城市级灾难 │ DNS 切换到异地灾备中心(两地三中心) │ │ 数据误删 │ 从灾备中心回溯 binlog 恢复(延迟复制) │ └────────────────┴───────────────────────────────────┘ ```  [编辑 Excalidraw 源图](/images/java-interview-copy/business-scenario/50-three-high-scenarios-three-high-disaster-recovery-topology-diagram.excalidraw) **方案对比** | 方案 | 可用性 | RTO(恢复时间) | RPO(数据丢失) | 成本 | |------|--------|---------------|----------------|------| | 单机房多副本 | 99.9% | 分钟级 | 0(同步复制) | 低 | | 同城双活 | 99.99% | 秒级 | ~0 | 中 | | 两地三中心 | 99.999% | 分钟级 | 秒级 | 高 | | 多云部署 | 99.999%+ | 秒级 | ~0 | 极高 | **面试回答要点** 1. 先说可用性计算:一个系统的整体可用性 = 所有组件的可用性乘积(串联关系),或 `1 - ∏(1-Ai)`(并联关系) 2. 区分 RTO(多久恢复)和 RPO(丢多少数据) 3. 核心手段:冗余 + 自动故障转移 + 容灾演练 4. 加分项:提到混沌工程(Chaos Engineering)——定期在生产环境注入故障来验证容灾能力 **追问** **Q:MySQL 主从切换会不会丢数据?** A:半同步复制(semi-sync)可以做到不丢——主库提交事务前必须等至少一台从库确认收到 binlog。缺点是有性能损耗(约 20%),所以要权衡。 **Q:DNS 切换机房要多久?用户能感知吗?** A:DNS TTL 一般设 60 秒,切换后最多 60 秒内所有用户流量都切到新机房。如果要秒级切换,需要 Anycast IP 或自研 GSLB。 > 架构师视角:同城双活最容易被忽略的不是"怎么切",而是"切了之后数据怎么办"。双活意味着两个机房都能写,如果只是主从(一个写、一个只读),本质仍是"主备",只是备机分担了读流量。真正的双活要么做单元化(按用户分片,各自只写自己那一片),要么接受跨机房写冲突的复杂处理。所以"同城双活"这个词在面试里最好说清楚:是"双读单写"还是"双读双写",两者成本差一个数量级。RPO 为 0 的说法也只在使用同步/半同步复制时成立,异步复制下 RPO 不为 0。 --- #### Q6:服务熔断、降级、限流的区别与联动是什么? **场景描述** 支付服务依赖风控系统。风控系统响应变慢(从 50ms 升到 5s),导致支付服务线程全被占用,进而影响所有支付请求。最终支付服务也挂了,再导致上游订单服务不可用——这就是"雪崩"。 ``` 雪崩传导链: 风控服务变慢 → 支付服务线程池耗尽 → 支付服务不可用 → 订单服务调用支付超时 → 订单服务线程池耗尽 → → 网关层超时 → 用户看到白屏 ``` **核心概念对比**  *图:熔断、降级、限流的定义类比与策略* ``` ┌────────┬──────────────────────────────────────────────┐ │ 熔断 │ 下游服务不可用时,快速失败不再调用 │ │ │ 类比:家里保险丝断了 → 整条线路不再供电 │ │ │ 状态机:CLOSED → OPEN → HALF_OPEN → CLOSED │ ├────────┼──────────────────────────────────────────────┤ │ 降级 │ 舍弃非核心功能,保住核心链路 │ │ │ 类比:双11不显示每单优惠明细 → 只显示总价就下单 │ │ │ 策略:返回兜底值 / 返回缓存 / 返回默认页 │ ├────────┼──────────────────────────────────────────────┤ │ 限流 │ 控制请求速率,超过阈值的直接拒绝 │ │ │ 类比:景区限流 → 超过承载量就不让进了 │ │ │ 策略:QPS 限流 / 并发线程数限流 / 排队等待 │ └────────┴──────────────────────────────────────────────┘ ``` **方案一:Sentinel 三板斧联动**  *图:Sentinel 限流熔断降级三道关卡* ``` 请求进来 │ ┌──────▼──────┐ │ 限流 │ ← 第一关:超过 QPS 阈值直接拒绝 │ (Flow) │ └──────┬──────┘ │ 通过 ┌──────▼──────┐ │ 熔断 │ ← 第二关:下游错误率 > 50% 触发熔断 │ (Degrade) │ └──────┬──────┘ │ 通过 ┌──────▼──────┐ │ 降级 │ ← 第三关:系统负载过高,主动降级 │ (Fallback) │ └──────┬──────┘ │ 正常业务逻辑 ``` ```java @Service public class PaymentService { @Autowired private RiskControlClient riskControlClient; /** * 限流:payment-create 接口每秒最多 5000 次 * 熔断:下游异常比例 > 50% 时,10 秒内直接熔断 * 降级:熔断/限流后执行 fallback 返回默认值 */ @SentinelResource( value = "payment-create", fallback = "paymentFallback", // 降级逻辑 blockHandler = "paymentBlockHandler", // 限流/熔断处理 fallbackClass = PaymentService.class // fallback 和 blockHandler 是 static 方法时指定 ) public PaymentResult createPayment(PaymentRequest req) { // 1. 调用风控(可能超时) RiskResult risk = riskControlClient.check(req.getUserId()); if (!risk.isPassed()) { return PaymentResult.fail("风控不通过"); } // 2. 核心支付逻辑 return doPayment(req); } /** * 降级处理:返回安全的兜底值 * 触发条件:业务异常(非 BlockException) */ public static PaymentResult paymentFallback(PaymentRequest req, Throwable e) { // 返回缓存的风控结果或标记为"人工审核" return PaymentResult.pending("系统繁忙,订单已受理将人工审核"); } /** * 限流/熔断处理:快速失败 * 触发条件:FlowException / DegradeException */ public static PaymentResult paymentBlockHandler( PaymentRequest req, BlockException e) { if (e instanceof DegradeException) { log.warn("支付服务熔断中..."); } return PaymentResult.fail("系统繁忙,请稍后再试"); } } ``` **方案二:熔断状态机详解**  *图:熔断器 CLOSED / OPEN / HALF_OPEN 状态机* ``` ┌──────────┐ 请求成功 │ CLOSED │ 请求失败次数 >= 阈值 ┌───────────│ (闭合) │────────────┐ │ └──────────┘ │ │ ▼ │ ┌──────────────┐ │ │ OPEN │ │ │ (断开) │ │ │ 快速失败 │ │ └──────┬───────┘ │ │ │ 等待 sleepWindowMs 后 │ │ │ ┌──────▼───────┐ │ 成功 ◄── │ HALF_OPEN │──► 失败 │ │ (半开) │ │ │ 探测请求 │ └───────────────────────────│ └──────┐ └───────────────────────┘ ``` ```java // Sentinel 熔断规则配置 @Configuration public class SentinelDegradeConfig { @PostConstruct public void initDegradeRules() { List<DegradeRule> rules = new ArrayList<>(); // 慢调用比例熔断 DegradeRule slowCallRule = new DegradeRule("payment-create") .setGrade(RuleConstant.DEGRADE_GRADE_RT) // 慢调用比例 .setCount(500) // RT > 500ms .setSlowRatioThreshold(0.5) // 比例 > 50% .setTimeWindow(10) // 熔断时长 10 秒 .setMinRequestAmount(10); // 最小请求数 10 rules.add(slowCallRule); // 异常比例熔断 DegradeRule exceptionRule = new DegradeRule("risk-check") .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO) .setCount(0.5) // 异常比例 > 50% .setTimeWindow(10); rules.add(exceptionRule); // 异常数熔断 DegradeRule exceptionCountRule = new DegradeRule("sms-send") .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT) .setCount(20) // 1 分钟内异常 > 20 次 .setTimeWindow(10); rules.add(exceptionCountRule); DegradeRuleManager.loadRules(rules); } } ``` **方案对比** | 手段 | 触发条件 | 作用范围 | 恢复方式 | 用户感知 | |------|---------|---------|---------|---------| | 限流 | 超过阈值(QPS/线程数) | 入口控制 | 自动恢复(下一秒) | 部分用户被拒 | | 熔断 | 下游异常率高 | 下游隔离 | 半开探测成功恢复 | 快速失败 | | 降级 | 系统负载高 / 熔断触发 | 功能取舍 | 自动恢复 | 功能降级但可用 | **面试回答要点** 1. 先说清三者的定义和区别(一个比喻就够:限流=景区限流,熔断=保险丝,降级=大促隐藏不重要的功能) 2. 强调三者是**联动**的,不是独立的:高负载时先限流→限流不够用触发降级→下游异常则熔断 3. 半开探测(HALF_OPEN)是关键设计——防止"假恢复"导致的反复熔断 4. 加分项:Sentinel vs Hystrix 对比(Hystrix 线程池隔离有额外开销,Sentinel 信号量隔离更轻量) **追问** **Q:熔断和降级到底什么区别?很多人分不清。** A:熔断是"我不调用你了,因为你挂了"(对下游的保护);降级是"我少做点事,先保证活着"(对自己的保护)。熔断触发后通常要配套降级逻辑(快速返回兜底值)。 **Q:HALF_OPEN 状态下放多少探测请求?** A:Sentinel 默认放 1 个探测请求。如果这个请求成功了→CLOSE;失败了→重新 OPEN,继续等待。 > 架构师视角:三者最容易被混淆的点在"谁保护谁"。限流保护的是自己(不被打爆),熔断保护的是调用方(不被下游拖死),降级牺牲的是功能(保住链路)。落地时的常见坑是"只配了限流没配降级"——限流触发后如果没有 fallback,用户直接拿到 500,体验比返回一个降级结果更差。另外熔断的阈值要按依赖的重要程度区分:核心依赖(如支付风控)宁可快速失败也不要长时间熔断,非核心依赖(如推荐、评价)大可以熔断后长时间走兜底。 --- #### Q7:灰度发布与蓝绿部署怎么做? **场景描述** 新版支付服务开发完成,需要上线。不能让所有用户同时用新版——万一把钱算错了,全公司都得背锅。需要先让 1% 的用户用新版,观察 30 分钟没问题后逐步放量。 ``` 发布流程: 1% 灰度 → 观察 30 分钟 → 没问题 → 扩大到 10% → 观察 1 小时 → 扩大到 50% → 观察 2 小时 → 全量发布 ``` **方案一:网关层流量染色 + 标签路由**  *图:按 Header 灰度路由到 v1 与 v2 实例* ``` ┌─────────────────┐ 请求(带 Header)──────→│ Spring Cloud │ X-Version: v2 │ Gateway │ X-UID: 10086 │ │ │ 根据 Header 路由 │ └───┬─────────┬────┘ │ │ v1 标签 │ │ v2 标签 ┌──────────────▼┐ ┌────▼──────────────┐ │ payment-svc │ │ payment-svc │ │ version: v1 │ │ version: v2 │ │ 实例数: 99 │ │ 实例数: 1 │ └───────────────┘ └────────────────────┘ ``` ```yaml # Nacos 注册中心灰度实例的元数据 spring: cloud: nacos: discovery: metadata: version: v2 # 版本标签 lane: canary # 泳道标签 ``` ```java // 网关层灰度路由过滤器 @Component public class CanaryRouteFilter implements GlobalFilter, Ordered { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { ServerHttpRequest request = exchange.getRequest(); // 1. 从请求中提取灰度标识 String version = request.getHeaders().getFirst("X-Version"); String uid = request.getHeaders().getFirst("X-UID"); // 2. 判断是否命中灰度 String targetVersion = determineVersion(version, uid); // 3. 设置路由元数据,LB 会根据 version 选择对应实例 if (targetVersion != null) { exchange.getAttributes().put("nacos.version", targetVersion); } return chain.filter(exchange); } private String determineVersion(String headerVersion, String uid) { // 方式 1:Header 指定版本(测试专用) if ("v2".equals(headerVersion)) { return "v2"; } // 方式 2:根据 UID 哈希按比例分流 if (uid != null) { int hash = Math.abs(uid.hashCode()); if (hash % 100 == 0) { // 尾号 0 → 1% 用户 return "v2"; } } return null; // null = 走默认版本 v1 } @Override public int getOrder() { return -1; // 最高优先级 } } ``` ```java // 自定义负载均衡:根据 version 选择实例 @Component public class CanaryLoadBalancer implements ReactorServiceInstanceLoadBalancer { @Override public Mono<Response<ServiceInstance>> choose(Request request) { // 从上下文中取出目标版本 String targetVersion = ((DefaultRequestContext) request.getContext()) .getExchange().getAttribute("nacos.version"); return serviceInstanceListProvider.get().next().map(instances -> { List<ServiceInstance> candidates = instances.stream() .filter(i -> { String v = i.getMetadata().get("version"); return targetVersion == null || targetVersion.equals(v); }) .collect(Collectors.toList()); if (candidates.isEmpty()) { // 灰度实例全挂了,降级到稳定版 candidates = instances.stream() .filter(i -> "v1".equals(i.getMetadata().get("version"))) .collect(Collectors.toList()); } // 从符合条件的实例中轮询选择 int idx = ThreadLocalRandom.current().nextInt(candidates.size()); return new DefaultResponse(candidates.get(idx)); }); } } ``` **方案二:蓝绿部署**  *图:蓝绿部署两套环境与一键切换五步* ``` 蓝绿部署(非灰度,而是快速切换): ┌──────────────┐ ┌──────────────┐ │ BLUE 环境 │ │ GREEN 环境 │ │ 旧版 v1.0 │ │ 新版 v2.0 │ │ 100% 流量 │ │ 预发布验证 │ └──────────────┘ └──────────────┘ ↑ ┌──────┴─────────────────────────┐ │ 负载均衡 / 网关 │ │ 切换:修改路由规则一键切换 │ │ BLUE → GREEN 只需 1 秒 │ └────────────────────────────────┘ 操作步骤: 1. 部署 GREEN 环境(v2.0),与 BLUE 并行运行 2. GREEN 环境做冒烟测试 3. 一键切换负载均衡 → 100% 流量到 GREEN 4. 观察 30 分钟 → 有问题一键切回 BLUE 5. 确认没问题 → 销毁 BLUE 环境 ``` **方案对比** | 方案 | 切换时间 | 资源开销 | 回滚速度 | 适用场景 | |------|---------|---------|---------|---------| | 灰度发布(金丝雀) | 渐进(小时级) | 低 | 秒级(切标签) | 日常迭代 | | 蓝绿部署 | 秒级 | 高(双倍资源) | 秒级(切路由) | 重大版本升级 | | 滚动发布 | 渐进 | 低 | 分钟级(逐台回滚) | 无状态服务 | **面试回答要点** 1. 先说灰度发布和蓝绿部署的区别:灰度是"逐步放量",蓝绿是"双环境一键切换" 2. 流量染色的核心手段:请求 Header 透传、UID 哈希取模、Cookie 标记 3. 标签路由框架:Spring Cloud + Nacos 元数据 / K8s Label Selector 4. 加分项:提到全链路灰度(不只是网关层,RPC/DB/MQ 调用也要透传灰度标签) **追问** **Q:灰度发布时数据库怎么隔离?** A:① 如果只是逻辑变更(代码兼容新旧表结构)→ 不需要隔离;② 如果有表结构变更 → 用影子表(如 `orders_v2`),灰度用户读写新表;③ 推荐的做法是先发布兼容代码(读写旧表),再灰度切新表。 **Q:灰度用户出问题怎么快速止损?** A:网关层动态配置,修改灰度比例到 0% 或者直接删除灰度路由规则,秒级生效(Nacos 配置变更 + 监听器实时刷新)。 > 架构师视角:灰度最难的从来不是"网关怎么分流",而是"数据层能不能跟上"。如果新版本改了表结构、改了缓存 key 格式、改了 MQ 消息体,而灰度期间新旧版本要同时跑,就必须保证数据格式双向兼容,否则会出现"新版本写的缓存旧版本读不懂"这类线上事故。所以成熟团队的做法是"先发布兼容代码 → 再切数据 → 最后清理旧代码",把一次变更拆成多次可回滚的发布。另一个细节:UID 哈希取模分流时,同一个用户要稳定命中同一版本(否则用户会看到页面一会儿新一会儿旧),所以要用稳定的用户标识做哈希,而不是随机的请求 ID。 --- #### Q8:监控告警体系怎么搭建? **场景描述** 半夜 3 点,支付服务挂了 15 分钟后才被用户投诉发现。如果有监控,应该在服务刚出问题时(错误率 > 1% 持续 1 分钟)就自动告警通知值班人员。 ``` 监控的目标不是"发现故障",而是"比用户更早发现故障"。 ``` **方案一:黄金指标体系** ``` Google SRE 四大黄金指标: 1. 延迟(Latency):请求耗时 - P50 / P90 / P99 分位数 - 关注长尾:P99 > 1s 说明有慢请求 2. 流量(Traffic):系统承载的请求量 - QPS / TPS / 连接数 - 突增 300% → 可能被攻击 3. 错误(Errors):失败请求的比例 - 5xx 错误率、业务异常率 - 错误率 > 1% → 告警 4. 饱和度(Saturation):资源使用程度 - CPU / 内存 / 磁盘 / 连接池 / 线程池 - CPU > 80% 持续 5 分钟 → 准备扩容 四个指标一起看,而不是孤立地看某一个。 ``` **方案二:监控分层架构**  *图:从基础设施到告警的五层监控体系* ``` ┌─────────────────────────────────────────────────────┐ │ 1. 基础设施层 │ │ CPU / 内存 / 磁盘 / 网络 / JVM GC │ │ 工具:Prometheus + Node Exporter + Grafana │ ├─────────────────────────────────────────────────────┤ │ 2. 中间件层 │ │ MySQL 慢查询 / Redis 命中率 / MQ 堆积 / ES 集群状态 │ │ 工具:MySQL Exporter / Redis Exporter / Kafka │ │ Exporter / JMX Exporter │ ├─────────────────────────────────────────────────────┤ │ 3. 应用层 │ │ 接口 QPS / RT / 错误率 / 业务指标面板 │ │ 工具:Micrometer + Prometheus + Spring Actuator │ ├─────────────────────────────────────────────────────┤ │ 4. 业务层 │ │ 订单量 / 支付成功率 / 注册转化率 / GMV │ │ 工具:自定义埋点 + 实时大盘 │ ├─────────────────────────────────────────────────────┤ │ 5. 告警层 │ │ 告警规则 → 告警降噪 → 通知 → 处理 → 复盘 │ │ 工具:AlertManager / Prometheus / 飞书/钉钉/电话 │ └─────────────────────────────────────────────────────┘ ``` ```java // 应用层核心指标采集 @RestController @RequestMapping("/actuator") public class MetricsExporter { private final MeterRegistry meterRegistry; public MetricsExporter(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; } @PostConstruct public void registerCustomMetrics() { // 1. 业务指标:下单计数器 Counter.builder("business.orders.created") .description("订单创建数量") .register(meterRegistry); // 2. 业务指标:支付成功/失败计数器(带标签) Counter.builder("business.payments") .description("支付结果") .tags("status", "success") .register(meterRegistry); // 3. 分布式定时器:记录各接口耗时分布 Timer.builder("http.requests") .description("HTTP 请求耗时") .publishPercentiles(0.5, 0.9, 0.99) // P50, P90, P99 .register(meterRegistry); // 4. 技术指标:线程池饱和度 Gauge.builder("executor.pool.size", threadPoolExecutor, ThreadPoolExecutor::getPoolSize) .description("线程池当前线程数") .register(meterRegistry); Gauge.builder("executor.queue.size", threadPoolExecutor, tp -> tp.getQueue().size()) .description("线程池队列堆积数") .register(meterRegistry); } } ``` ```yaml # Prometheus 告警规则 groups: - name: application_alerts rules: # 错误率 > 5% 持续 1 分钟 → 告警 - alert: HighErrorRate expr: | rate(http_server_requests_seconds_count{status=~"5.."}[1m]) / rate(http_server_requests_seconds_count[1m]) > 0.05 for: 1m labels: severity: critical annotations: summary: "服务 {{ $labels.application }} 错误率过高" description: "当前错误率 {{ $value | humanizePercentage }}" # P99 RT > 2s 持续 5 分钟 → 告警 - alert: HighLatency expr: | histogram_quantile(0.99, rate(http_server_requests_seconds_bucket[5m])) > 2 for: 5m labels: severity: warning annotations: summary: "P99 延迟超过 2 秒" # 线程池队列堆积 > 1000 → 告警 - alert: ThreadPoolSaturation expr: executor_queue_size > 1000 for: 2m labels: severity: warning annotations: summary: "线程池队列堆积 {{ $value }} 条" ``` **方案三:告警降噪 + On-call 机制** ``` 告警降噪的四种策略: 1. 告警聚合: 同一服务 3 分钟内的多条相同告警 → 合并成 1 条发送 2. 告警抑制: 机房 A 断网告警 → 抑制该机房所有服务的"连接超时"告警 (因为根因是网络断了,不是每个服务都坏了) 3. 告警静默: 发版时间段(凌晨 2~4 点)→ 静默预期内的告警 4. 告警升级: P3 告警 10 分钟没响应 → 升级 P2 → 30 分钟没响应 → 升级 P1 → 电话 ```  *图:On-call 按 P0 到 P3 分级通知升级* ``` On-call 排班机制: ┌────────────────────────────────┐ │ P0(紧急):全公司范围通知 │ │ → 电话 + 短信 + IM + 邮件 │ │ → 5 分钟未确认 → 通知 Leader │ │ → 15 分钟未确认 → 通知总监 │ ├────────────────────────────────┤ │ P1(重要):值班 + TL │ │ → 电话 + IM │ ├────────────────────────────────┤ │ P2(一般):值班 + 群消息 │ │ → IM + 邮件 │ ├────────────────────────────────┤ │ P3(提醒):群里丢一条消息 │ │ → 第二天上班处理 │ └────────────────────────────────┘ ``` **方案对比** | 层级 | 关注指标 | 采集频率 | 存储 | 适用场景 | |------|---------|---------|------|---------| | 基础设施 | CPU/内存/磁盘/网络 | 15~30s | Prometheus TSDB | 容量规划 | | 中间件 | 慢查询/命中率/堆积 | 15~30s | Prometheus TSDB | 性能排查 | | 应用层 | QPS/RT/错误率 | 实时 | Prometheus + 聚合 | 故障发现 | | 业务层 | 订单量/转化率/GMV | 1min | 数据库/ES | 业务决策 | **面试回答要点** 1. 先说黄金指标四个维度(延迟/流量/错误/饱和度),证明有系统化思维 2. 告警不只是"发通知",重点是告警降噪和升级机制 3. 监控数据不是越多越好——要找"领先指标"(能在故障发生前就预示问题的指标) 4. 加分项:提到可观测性三支柱(Metrics / Logs / Traces)和 OpenTelemetry **追问** **Q:监控和日志和链路追踪,三个有什么区别?** A:Metrics(指标)告诉你"有没有问题",Logs(日志)告诉你"问题是什么",Traces(链路)告诉你"问题在哪一环节"。三者互补:告警从 Metrics 来,排查用 Traces 定位,定位后用 Logs 分析根因。 **Q:如果告警太多了怎么办?(告警疲劳)** A:① 设定告警抑制规则(根因告警抑制派生告警);② 提高告警阈值(错误率从 1% 提到 5%);③ 区分工作时间/非工作时间告警级别;④ 定期 Review 告警,关闭不再需要的规则。 > 架构师视角:监控体系最大的敌人不是"漏报"而是"误报"——当值班的人每天收到几百条告警,真正致命的 P0 也会被淹没。所以指标要分层:技术指标(CPU、GC、线程池)用于定位,业务指标(支付成功率、下单量)用于发现。业务指标往往更"领先"——支付成功率从 99.9% 掉到 99% 时,技术指标可能还一切正常。另外告警阈值不是拍脑袋定的,应该基于历史数据的波动范围,取"正常波动的上界",否则大促期间的正常流量增长会刷屏。 --- ### 高性能(High Performance) #### Q9:千万级数据分页如何优化? **场景描述** 订单表有 3000 万条数据,前端展示订单列表(每页 20 条)。用户翻到第 5000 页,SQL 执行了 5 秒多才返回,直接超时。 ```sql -- 罪魁祸首:大偏移量深分页 SELECT * FROM orders WHERE user_id = 10086 ORDER BY id DESC LIMIT 100000, 20; -- 跳过前 10 万行! -- MySQL 实际干了什么? -- 1. 扫描 id 索引,从第 1 行读到第 100020 行 -- 2. 回到聚簇索引读完整行数据(100020 次回表!) -- 3. 丢弃前 100000 行,只返回最后 20 行 -- 前 100000 行的 IO 全浪费了! ``` **方案一:游标分页(推荐)** ```java // 游标分页:每次用上一页最后一条的 ID 作为下一页的起点 public class CursorPaginationService { @Autowired private OrderMapper orderMapper; /** * 游标分页查询 * @param cursor 上一页最后一条记录的 ID(首次传 null) * @param size 每页大小 */ public PageResult<OrderVO> findByCursor(Long cursor, int size) { // size + 1 用于判断是否还有下一页 List<Order> orders = orderMapper.findByCursor(cursor, size + 1); boolean hasMore = orders.size() > size; if (hasMore) { orders = orders.subList(0, size); } Long nextCursor = orders.isEmpty() ? null : orders.get(orders.size() - 1).getId(); return new PageResult<>(toVOList(orders), hasMore, nextCursor); } } ``` ```xml <!-- Mapper XML --> <select id="findByCursor" resultType="Order"> SELECT id, order_no, amount, status, create_time FROM orders WHERE user_id = #{userId} <if test="cursor != null"> AND id < #{cursor} <!-- 用主键替代 OFFSET --> </if> ORDER BY id DESC LIMIT #{size} </select> ``` ``` 为什么快? cursor = 100020 → WHERE id < 100020 ORDER BY id DESC LIMIT 20 → 索引直接定位到 id=100020 的前面 20 条 → 不需要扫描前 10 万行!复杂度 O(log N) → O(1) ``` **方案二:覆盖索引 + 子查询** ```sql -- 先用覆盖索引查出 20 个 ID(只需读索引,不需要回表) -- 再用 ID 去关联查完整数据(只回表 20 次) SELECT o.* FROM orders o INNER JOIN ( SELECT id FROM orders WHERE user_id = 10086 ORDER BY id DESC LIMIT 100000, 20 ) AS tmp ON o.id = tmp.id; ``` ```java // MyBatis-Plus 也可以用子查询方式 public PageResult<Order> deepPageQuery(Long userId, int pageNo, int pageSize) { int offset = (pageNo - 1) * pageSize; // Step 1: 子查询只扫索引拿到 ID 列表 List<Long> ids = orderMapper.selectIdsByPage(userId, offset, pageSize); if (ids.isEmpty()) { return PageResult.empty(); } // Step 2: 拿 ID 列表去查完整数据(走主键索引,速度快) List<Order> orders = orderMapper.selectByIds(ids); return new PageResult<>(orders); } ``` ```xml <select id="selectIdsByPage" resultType="long"> SELECT id FROM orders WHERE user_id = #{userId} ORDER BY id DESC LIMIT #{offset}, #{size} </select> ``` ``` 为什么比原始写法快? 原SQL: 扫描 100020 行 → 回表 100020 次 → 丢 100000 行 优化后: 扫描索引 100020 行 → 回表 20 次 性能提升: 回表次数从 100020 → 20, IO 减少了 5000 倍 ``` **方案三:ES 搜索引擎(适合复杂搜索场景)** ```java // 订单列表 > 10000 页之后走 ES 搜索 @Service public class OrderSearchService { @Autowired private ElasticsearchRestTemplate esTemplate; public PageResult<OrderVO> searchByES(Long userId, int pageNo, int pageSize) { // 如果翻页超过 500 页(10000 条数据),切到 ES if (pageNo > 500) { return deepPageByES(userId, pageNo, pageSize); } // 500 页以内走 MySQL,用游标分页 return deepPageByMySQL(userId, pageNo, pageSize); } private PageResult<OrderVO> deepPageByES(Long userId, int pageNo, int pageSize) { // ES 的 search_after 替代深度分页的 from+size // from+size 限制: from + size > 10000 时 ES 会拒绝(可配置) NativeSearchQuery query = new NativeSearchQueryBuilder() .withQuery(QueryBuilders.termQuery("user_id", userId)) .withSort(SortBuilders.fieldSort("id").order(SortOrder.DESC)) .withPageable(PageRequest.of(0, pageSize)) // 用 search_after 而非 from .build(); SearchHits<OrderDocument> hits = esTemplate.search(query, OrderDocument.class); return convertToPageResult(hits); } } ``` ``` ES 深度分页的三种方式: from+size: 适合前 10000 条,超过要改 max_result_window scroll: 适合全量导出,维护上下文开销大(已不推荐) search_after: 适合实时深度翻页,用上一页最后一条排序值作为起点(推荐) ``` **方案对比** | 方案 | 深分页性能 | 随机跳页 | 额外依赖 | 适用场景 | |------|-----------|---------|---------|---------| | 游标分页(Cursor) | ★★★★★ | 不支持 | 无 | 瀑布流/加载更多 | | 覆盖索引+子查询 | ★★★★ | 支持 | 无 | 需要分页条的传统列表 | | ES search_after | ★★★★★ | 不支持 | ES 集群 | 复杂搜索 + 深分页 | | 原始 LIMIT OFFSET | ★(10000 行以上极慢) | 支持 | 无 | 小数据量 | **面试回答要点** 1. 先说深分页为什么慢:MySQL 需要扫描并丢弃 OFFSET 之前的所有行 2. 首选游标分页(Cursor-based Pagination),如果产品能接受"只能翻下一页" 3. 如果必须支持跳页:用覆盖索引 + 子查询减少回表 4. 加分项:ES search_after 是 ES 7.x+ 深度分页的最佳实践,scroll 已不推荐 **追问** **Q:游标分页用户不能直接跳到第 100 页怎么办?** A:用"假分页"——前端只展示"上一页/下一页"按钮,不显示页码数字。Twitter、抖音、朋友圈都是这样做的。用户体验研究也表明,几乎没有用户会翻到第 50 页以后。 **Q:如果用 ES 的 from+size,超过 10000 条怎么办?** A:① 不推荐调大 `max_result_window`(会增加内存压力和 GC);② 用 search_after API;③ 做业务限制:搜索结果最多展示前 10000 条(用户也不会翻到 1000 页之后)。 > 架构师视角:深分页本质是"产品需求 vs 数据库能力"的矛盾。用户真正想要的往往不是"第 5000 页",而是"快速找到某条订单"——那更应该做搜索/筛选而不是翻页。所以最好的优化往往是改需求:把"翻到第 N 页"改成"按条件筛选 + 游标滚动"。如果做不到,退而求其次用覆盖索引 + 子查询,它支持跳页但仍有 OFFSET 的扫描成本,只是把回表从 10 万次降到了 20 次。 --- #### Q10:接口响应从 2s 优化到 50ms 的全过程是怎样的? **场景描述** 一个商品详情页接口,返回商品信息 + 库存 + 促销 + 评价摘要。线上 P99 延迟 2000ms,用户明显感知卡顿。需要优化到 50ms 以内。  *图:商品详情原始链路各步骤串行耗时* ``` 原始链路(2000ms): 查商品基本信息 → DB 查询 150ms 查库存 → DB 查询 200ms 查促销活动 → 远程调用 500ms 查用户会员信息 → 远程调用 400ms 查评价摘要 → DB 聚合 600ms JSON 序列化 50ms ──────────────────────────────────────── 总计:1900ms(串行) ``` **优化第一层:加缓存(2000ms → 200ms)** ```java @Service public class ProductDetailService { @Autowired private StringRedisTemplate redisTemplate; @Autowired private ProductMapper productMapper; public ProductDetailVO getProductDetail(Long productId) { // 1. 先查缓存 String cacheKey = "product:detail:" + productId; String cached = redisTemplate.opsForValue().get(cacheKey); if (cached != null) { return JSON.parseObject(cached, ProductDetailVO.class); } // 2. 缓存未命中 → 查 DB(慢) ProductDetailVO detail = buildFromDB(productId); // 3. 写回缓存(TTL 随机化防雪崩) redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(detail), 300 + ThreadLocalRandom.current().nextInt(60), TimeUnit.SECONDS); return detail; } } ``` **优化第二层:异步并行(200ms → 80ms)** ```java // 改为 CompletableFuture 并行调用,而非串行 public ProductDetailVO getProductDetailAsync(Long productId) { long start = System.currentTimeMillis(); // 所有独立查询并行发起 CompletableFuture<Product> productFuture = CompletableFuture.supplyAsync(() -> productMapper.selectById(productId)); CompletableFuture<Integer> stockFuture = CompletableFuture.supplyAsync(() -> inventoryService.getStock(productId)); CompletableFuture<List<Promotion>> promoFuture = CompletableFuture.supplyAsync(() -> promotionService.getPromotions(productId)); CompletableFuture<UserLevel> userFuture = CompletableFuture.supplyAsync(() -> userService.getUserLevel(currentUserId())); CompletableFuture<ReviewSummary> reviewFuture = CompletableFuture.supplyAsync(() -> reviewService.getSummary(productId)); // 等待所有完成(最长的一个决定总耗时) CompletableFuture.allOf(productFuture, stockFuture, promoFuture, userFuture, reviewFuture).join(); // 组装结果(此时所有数据已就绪) ProductDetailVO vo = assemble(productFuture.join(), stockFuture.join(), promoFuture.join(), userFuture.join(), reviewFuture.join()); log.info("查询耗时: {}ms", System.currentTimeMillis() - start); return vo; } ``` ``` 串行: 150 + 200 + 500 + 400 + 600 = 1850ms 并行: max(150, 200, 500, 400, 600) = 600ms ← 3 倍提升 再配合缓存(缓存的商品信息 1ms + 并行的远程调用 600ms): 缓存命中场景: max(1, 200, 500, 400, 600) = 600ms → 还不够 进一步优化: 远程调用也加本地缓存 → max(1, 1, 1, 1, 600) = 600ms 评价摘要也加缓存 → max(1,1,1,1,1) = 1ms → 目标达成! ``` **优化第三层:批量 + 索引 + SQL 优化(80ms → 50ms)** ```java // 对于不可避免的数据库查询,进一步优化 @Repository public class ProductMapper { // 1. 只查需要的字段,不用 SELECT * @Select("SELECT id, name, price, main_image, brief FROM product WHERE id = #{id}") Product selectBriefById(Long id); // 2. 利用索引:确保 WHERE 条件有索引覆盖 @Select("SELECT id, avg_score, total_count FROM review_summary " + "WHERE product_id = #{productId}") ReviewSummary selectReviewSummary(Long productId); // 索引: CREATE INDEX idx_product_id ON review_summary(product_id); } ``` ```sql -- 3. 批量查询替代 N+1 查询 -- 不好:循环查 SELECT * FROM promotion WHERE product_id = ?; ← 执行 N 次 -- 好:一次查完 SELECT * FROM promotion WHERE product_id IN (?, ?, ?, ...); ← 执行 1 次 ``` ```java // 批量查询优化 public Map<Long, List<Promotion>> batchGetPromotions(List<Long> productIds) { List<Promotion> all = promotionMapper.selectByProductIds(productIds); return all.stream().collect(Collectors.groupingBy(Promotion::getProductId)); } ``` **优化全过程总结**  *图:商品详情接口优化各阶段 P99 延迟* ``` ┌─────────────┬──────────────┬──────────────────────────┐ │ 优化阶段 │ P99 延迟 │ 手段 │ ├─────────────┼──────────────┼──────────────────────────┤ │ 原始 │ 2000ms │ 串行 + 全量查 DB │ │ +缓存(Redis)│ 200ms │ 热点商品缓存 │ │ +并行(CF) │ 80ms │ CompletableFuture 并行 │ │ +本地缓存 │ 30ms │ Caffeine 缓存远程调用结果 │ │ +SQL 优化 │ 20ms │ 覆盖索引 + 只查必要字段 │ │ +批量查询 │ 15ms │ 一次查多个 ID │ │ +连接池调优 │ 10ms │ 减少连接建立开销 │ │ 最终 │ ~10~50ms │ 综合所有手段 │ └─────────────┴──────────────┴──────────────────────────┘ ``` **面试回答要点** 1. 先说优化思路的顺序:缓存 → 异步 → 并行 → 批量 → 索引 → SQL 优化,从上到下逐层递进 2. 强调每层优化的收益递减——缓存收益最大,SQL 优化收益最小但要做的 3. 提到不要过早优化:先用 APM(如 SkyWalking)定位瓶颈,再针对性优化 4. 加分项:用 Amdahl 定律解释并行优化的理论上限(加速比 = 1 / (串行比例 + 并行比例/N)) **追问** **Q:加了并行后为什么还没到 50ms?** A:因为最慢的调用决定了总耗时(木桶效应)。如果评价摘要查询要 600ms,其他再快也没用。需要把评价摘要也拆成异步 + 缓存,或者接受评价数据"最终一致"(显示缓存中的旧评价,后台异步更新)。 **Q:这么多优化手段,面试时要全部说吗?** A:不需要。重点记住三层:① 缓存(Redis + 本地缓存);② 异步并行(CompletableFuture);③ 防热点(多级缓存 + 随机过期)。剩下的根据面试官追问展开。 > 架构师视角:注意表格里"原始 2000ms"与上方链路算出的 1900ms 略有差异,这是 P99(长尾)与均值口径不同导致的,讲的时候说明口径即可。并行化也不是免费的:`CompletableFuture.supplyAsync` 默认使用 `ForkJoinPool.commonPool()`,在高并发下如果任务里含阻塞 IO(DB、RPC),会把这个公共池打满、影响其他用到它的代码。生产上应显式传入自定义线程池,并给线程池设隔离与拒绝策略。另外并行会放大下游瞬时压力(原本串行的 5 个调用变成同时打下去),下游没做容量评估时反而更容易被打挂。 --- #### Q11:如何做全链路压测? **场景描述** 双11 前需要验证系统能否扛住预估的峰值流量(50 万 QPS)。但不能在生产环境真去刷 50 万单——会污染数据、触发风控、发真实短信。 ``` 全链路压测的核心挑战: 1. 压测流量不能污染生产数据(订单/支付/短信) 2. 压测流量不能影响真实用户 3. 压测结果要能反映真实生产环境的性能 ``` **方案一:流量染色 + 影子库**  *图:压测流量染色与中间件影子路由* ``` ┌─────────────────────────┐ 压测流量 ────────→│ 网关流量标染色 │ Header: │ X-Stress-Test: true │ X-Stress-Test: └────────┬────────────────┘ true │ ┌────────▼────────────────┐ │ 中间件层路由 │ │ DB: 影子库(stress_) │ │ Redis: 影子Key(stress:)│ │ MQ: 压测 Topic │ │ 短信: 拦截不发送 │ └─────────────────────────┘ ``` ```java // 1. 网关层流量标染色 @Component public class StressTestFilter implements GlobalFilter, Ordered { @Override public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { ServerHttpRequest request = exchange.getRequest(); String stressFlag = request.getHeaders().getFirst("X-Stress-Test"); if ("true".equals(stressFlag)) { // 将压测标记放入 ThreadLocal,全链路透传 StressTestContext.setStressTest(true); } return chain.filter(exchange) .doFinally(s -> StressTestContext.clear()); } @Override public int getOrder() { return -2; } } ``` ```java // 2. 数据源路由:根据压测标记切换影子库 @Component public class ShadowDataSourceRouter extends AbstractRoutingDataSource { @Override protected Object determineCurrentLookupKey() { if (StressTestContext.isStressTest()) { return "shadow"; // 影子数据源 } return "master"; // 生产数据源 } } ``` ```java // 3. Redis Key 隔离 @Component public class ShadowRedisTemplate { @Autowired private StringRedisTemplate redisTemplate; public void set(String key, String value) { redisTemplate.opsForValue().set(shadowKey(key), value); } public String get(String key) { return redisTemplate.opsForValue().get(shadowKey(key)); } private String shadowKey(String key) { return StressTestContext.isStressTest() ? "stress:" + key // 压测流量:key 带前缀隔离 : key; // 正常流量:原 key } } ``` ```java // 4. 短信/推送 Mock —— 压测流量不真实发送 @Service public class SmsService { public void send(String phone, String content) { if (StressTestContext.isStressTest()) { log.info("[压测] Mock 发送短信: phone={}, content={}", phone, content); return; // 压测直接返回,不真实发 } // 真实发送 smsClient.send(phone, content); } } ``` ```java // 5. ThreadLocal 全链路透传 public class StressTestContext { private static final ThreadLocal<Boolean> CONTEXT = new ThreadLocal<>(); public static void setStressTest(boolean value) { CONTEXT.set(value); } public static boolean isStressTest() { return Boolean.TRUE.equals(CONTEXT.get()); } public static void clear() { CONTEXT.remove(); } } ``` **方案二:流量录制回放**  *图:生产流量录制与压测环境回放流程* ``` 录制阶段(生产环境): 用户请求 ──→ 网关 ──→ 录制流量到文件/DB │ └──→ 记录请求 + 响应 + 子调用(MySQL/Redis/RPC) 回放阶段(压测环境): 录制文件 ──→ 压测引擎(JMeter/Gatling) ──→ 被压测系统 │ 对比实际响应 vs 录制响应 发现差异 → 可能为 Bug ``` ```java // 流量录制过滤器(生产环境低采样率) @Component public class TrafficRecorderFilter implements Filter { private static final double SAMPLE_RATE = 0.01; // 1% 采样 private static final String ES_INDEX = "traffic_records"; @Autowired private RestHighLevelClient esClient; @Override public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException { ContentCachingRequestWrapper wrapper = new ContentCachingRequestWrapper((HttpServletRequest) req); ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper((HttpServletResponse) resp); long start = System.currentTimeMillis(); try { chain.doFilter(wrapper, responseWrapper); } finally { // 1% 采样 → 异步写入 ES if (Math.random() < SAMPLE_RATE) { TrafficRecord record = new TrafficRecord(); record.setUri(wrapper.getRequestURI()); record.setMethod(wrapper.getMethod()); record.setRequestBody(new String(wrapper.getContentAsByteArray())); record.setResponseBody(new String( responseWrapper.getContentAsByteArray())); record.setDuration(System.currentTimeMillis() - start); record.setTimestamp(Instant.now()); // 异步写入,不阻塞请求 CompletableFuture.runAsync(() -> { try { IndexRequest indexReq = new IndexRequest(ES_INDEX) .source(JSON.toJSONString(record), XContentType.JSON); esClient.index(indexReq, RequestOptions.DEFAULT); } catch (Exception ignored) { // 录制失败不影响主业务 } }); } responseWrapper.copyBodyToResponse(); // 重要:把内容写回 } } } ``` **方案对比** | 方案 | 数据隔离 | 实现复杂度 | 压测真实性 | 适用场景 | |------|---------|-----------|-----------|---------| | 流量染色 + 影子库 | 好 | 高 | 高(和生产同环境) | 大促前全链路压测 | | 流量录制回放 | 好(单独环境) | 中 | 中(子调用是 mock) | 回归验证、容量评估 | | 单独压测环境 | 完全隔离 | 低 | 低(硬件/数据不同) | 日常小规模压测 | **面试回答要点** 1. 先说全链路压测 ≠ 单接口压测:需要经过网关→服务→DB→缓存→MQ 全部链路 2. 核心难点是数据隔离:用"流量染色" + "影子库"实现生产环境压测不污染数据 3. 压测流量的 ThreadLocal 标记需要全链路透传(跨线程/跨 RPC/跨 MQ) 4. 加分项:提到 JMeter 分布式压测 + 阶梯加压(预热 → 爬坡 → 峰值 → 回落) **追问** **Q:影子库的数据从哪来?** A:从生产库定期脱敏同步:① 只同步表结构;② 数据脱敏(手机号掩码、金额随机化);③ 数据量按比例缩放(生产 100W → 影子 10W)。 **Q:压测发现性能瓶颈后怎么处理?** A:先不着急加机器——先看瓶颈在哪:① CPU 瓶颈 → 加机器水平扩容;② DB 瓶颈 → 加索引/读写分离/分库分表;③ 下游瓶颈 → 加缓存/异步化/降级。扩容是最后的选择。 > 架构师视角:全链路压测最容易被低估的是"标记透传"。`ThreadLocal` 只在当前线程有效,一旦碰到线程池、异步任务、RPC 调用、MQ 消费,标记就会丢失——丢标记就意味着压测流量会走生产库、发真实短信。生产上的做法是把压测标记放到"跨进程上下文"里统一透传(如 RPC 隐式参数、MQ 消息属性、HTTP Header),并提供兜底校验(发现未标记但命中生产库的压测流量时直接拦截告警)。另一个前提是"生产环境压测"必须经过安全审批与流量上限控制,否则可能把真实用户一起拖下水。 --- #### Q12:JVM 调优实战怎么做? **场景描述** 订单服务部署在 4C8G 的虚拟机上,使用默认 JVM 参数。大促期间频繁 Full GC(STW > 2s),导致服务间歇性无响应,网关超时摘除实例。 ``` 现象: Young GC: 每 3 秒 1 次,每次 ~50ms Full GC: 每 10 分钟 1 次,每次 ~2.5s ← 致命! 根因分析: 堆 4G, 年轻代 1G, 老年代 3G 每秒产生 ~50MB 对象 → 20 秒填满年轻代 → 对象频繁晋升老年代 老年代 3G → CMS 并发失败 → 退化为 Serial Old → 长时间 STW ``` **方案一:GC 选型与参数调优** ```bash # === 推荐模板:G1 GC(JDK 8 需要 -XX:+UseG1GC,JDK 9+ 默认)=== # 适用:4G 以上堆,延迟敏感,希望 STW 可控 java -Xms4g -Xmx4g \ # 堆最小=最大,避免动态扩缩 -XX:+UseG1GC \ # G1 垃圾回收器 -XX:MaxGCPauseMillis=200 \ # 目标最大暂停时间 200ms -XX:G1HeapRegionSize=4m \ # Region 大小(堆大小的 1/2048 左右) -XX:InitiatingHeapOccupancyPercent=45 \ # 堆使用 45% 触发并发标记 -XX:+ParallelRefProcEnabled \ # 并行处理引用对象 -XX:+DisableExplicitGC \ # 禁止 System.gc() -XX:+HeapDumpOnOutOfMemoryError \ # OOM 时 dump 堆 -XX:HeapDumpPath=/data/logs/heap.hprof \ -XX:+PrintGCDetails \ # 打印 GC 日志 -XX:+PrintGCDateStamps \ -Xloggc:/data/logs/gc-%t.log \ -jar order-service.jar ``` ```bash # === 备选:ZGC(JDK 11+ 实验性,JDK 15+ 生产可用)=== # 适用:超大堆(16G+),要求 STW < 10ms 的极致低延迟场景 java -Xms16g -Xmx16g \ -XX:+UseZGC \ -XX:ConcGCThreads=4 \ # 并发 GC 线程数 -XX:+ZGenerational \ # JDK 21+ 分代 ZGC -jar order-service.jar ``` **方案二:内存分配优化** ```java /** * 常见内存问题及优化 */ public class MemoryOptimization { // ❌ 问题 1:频繁创建大对象 → 直接晋升老年代 public byte[] processLargeData() { // 1MB 的对象,超过 -XX:PretenureSizeThreshold?直接进老年代 return new byte[1024 * 1024]; // 每次调用产生 1MB } // ✅ 优化:对象池化复用 private final ObjectPool<byte[]> bufferPool = new GenericObjectPool<>(...); public byte[] processLargeDataOptimized() { byte[] buffer = bufferPool.borrowObject(); try { // 使用 buffer... return process(buffer); } finally { bufferPool.returnObject(buffer); } } // ❌ 问题 2:ThreadLocal 未清理 → 内存泄漏 private static final ThreadLocal<SimpleDateFormat> DATE_FORMAT = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd")); // ✅ 优化:线程池任务结束时清理 public void handleRequest() { try { String date = DATE_FORMAT.get().format(new Date()); } finally { DATE_FORMAT.remove(); // 必须 remove! } } // ❌ 问题 3:字符串拼接 → 产生大量中间对象 public String buildReport(List<String> items) { String result = ""; for (String item : items) { result += item + ","; // 每次循环创建新 String 对象 } return result; } // ✅ 优化:StringBuilder public String buildReportOptimized(List<String> items) { StringBuilder sb = new StringBuilder(items.size() * 20); // 预分配 for (String item : items) { sb.append(item).append(','); } return sb.toString(); } } ``` **方案三:直接内存(Direct Memory)管理** ```java // 直接内存问题:NIO 使用堆外内存,Xmx 管不住! // 设置 -XX:MaxDirectMemorySize=512m 防止无限制增长 @Configuration public class NettyConfig { // Netty 默认使用堆外内存(Direct Buffer),需要显式管理 @Bean public EventLoopGroup bossGroup() { NioEventLoopGroup group = new NioEventLoopGroup(1); // Netty 自带内存泄漏检测 ResourceLeakDetector.setLevel( ResourceLeakDetector.Level.PARANOID); // 开发环境开最高级别 return group; } // 使用池化的 Direct Buffer(Netty 默认开启) // -Dio.netty.allocator.type=pooled // -Dio.netty.noPreferDirect=false } ``` ```java // 排查直接内存泄漏 public class DirectMemoryMonitor { @Scheduled(fixedDelay = 30_000) public void monitorDirectMemory() { // 方式 1:JMX 获取 BufferPoolMXBean directPool = ManagementFactory.getPlatformMXBeans( BufferPoolMXBean.class).stream() .filter(p -> "direct".equals(p.getName())) .findFirst().orElse(null); if (directPool != null) { long used = directPool.getMemoryUsed(); long capacity = directPool.getTotalCapacity(); log.info("Direct Memory: used={}MB, capacity={}MB, count={}", used / 1024 / 1024, capacity / 1024 / 1024, directPool.getCount()); } // 方式 2:反射获取(兼容性更好) try { Class<?> c = Class.forName("java.nio.Bits"); Field maxMemory = c.getDeclaredField("maxMemory"); maxMemory.setAccessible(true); Field reservedMemory = c.getDeclaredField("reservedMemory"); reservedMemory.setAccessible(true); synchronized (c) { Long max = (Long) maxMemory.get(null); Long reserved = (Long) reservedMemory.get(null); log.info("Direct Memory used: {}MB / {}MB", reserved / 1024 / 1024, max / 1024 / 1024); } } catch (Exception e) { log.error("Failed to monitor direct memory", e); } } } ``` **GC 选型速查表**  *图:六种 GC 的目标延迟与 STW 特征* ``` ┌─────────┬──────────┬──────────────┬────────────────┐ │ GC 类型 │ 目标延迟 │ 适用堆大小 │ STW 特征 │ ├─────────┼──────────┼──────────────┼────────────────┤ │ Serial │ N/A │ < 256M │ 单线程, 长时间 │ │ Parallel│ 高吞吐 │ 1~4G │ 多线程, Full GC 长│ │ CMS │ ~200ms │ 4~8G │ 并发, 但会退化 │ │ G1 │ ~100ms │ 4~64G │ 分 Region, 可预测 │ │ ZGC │ < 1ms │ 16G~16T │ 全并发, 染色指针 │ │ Shenandoah│ < 1ms │ 4~64G │ 全并发, 转发指针 │ └─────────┴──────────┴──────────────┴────────────────┘ ``` **常见 JVM 参数模板** ```bash # === 模板 A:4C8G 通用 Web 服务(G1)=== -Xms4g -Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:G1HeapRegionSize=4m -XX:InitiatingHeapOccupancyPercent=45 -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m -XX:MaxDirectMemorySize=512m -XX:+DisableExplicitGC -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/logs/ -Xlog:gc*:file=/data/logs/gc-%t.log:time:filecount=10,filesize=100m # === 模板 B:2C4G 小内存服务(Serial / Parallel)=== -Xms2g -Xmx2g -XX:+UseParallelGC -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=256m -XX:MaxDirectMemorySize=256m -XX:+HeapDumpOnOutOfMemoryError # === 模板 C:16G+ 大堆低延迟(ZGC)=== -Xms16g -Xmx16g -XX:+UseZGC -XX:ConcGCThreads=4 -XX:MetaspaceSize=512m -XX:MaxMetaspaceSize=1g -XX:MaxDirectMemorySize=2g ``` **面试回答要点** 1. 先说 GC 的核心矛盾:吞吐量 vs 延迟,不存在两者都完美的 GC 2. 调优不是一上来就改参数,先看 GC 日志 + dump 分析 → 找到瓶颈 → 对症下药 3. 常见优化三板斧:① 堆大小对等(-Xms = -Xmx);② 选对 GC(4G+ 用 G1);③ 控制晋升速度(年轻代够大、大对象不进老年代) 4. 加分项:提到 ZGC 的原理(染色指针)和 JDK 21 的分代 ZGC **追问** **Q:什么时候用 G1,什么时候用 ZGC?** A:堆 < 16G 用 G1(生态成熟、调优经验多);堆 > 16G 且延迟要求 < 1ms 用 ZGC。ZGC 只关心延迟,不关心吞吐量(吞吐量通常比 G1 低 5~10%)。 **Q:线上 Full GC 频繁怎么办?** A:① 先 jmap -histo 看什么对象多(内存泄漏?);② jstat -gcutil 看各代使用率变化;③ 通过 MAT 分析堆 dump;④ 常见原因:大对象直接进老年代、MetaSpace 不够、System.gc() 被显式调用。排查后对应调整参数或修复代码。 > 架构师视角:调优的起点永远是"证据"而不是"参数"。默认参数导致 Full GC 频繁,往往是"年轻代太小 → 对象过早晋升 → 老年代压力大",此时把年轻代调大(或直接换 G1)比盲目加堆更有效。另外注意几处需结合版本确认的点:`-XX:+PrintGCDetails`/`-Xloggc` 是 JDK 8 的写法,JDK 9+ 统一为 `-Xlog:gc*`;ZGC 在 JDK 11 是实验性、JDK 15 起生产可用、`-XX:+ZGenerational` 需 JDK 21+ 才支持;CMS 已在 JDK 9 起被标记废弃、JDK 14 移除(具体以所用 JDK 版本为准)。上生产前务必在预发环境用同样的流量模型验证。 --- ## 四、总结与自测 ### Q:面试里怎么答这套题? **答题框架(四步):** 1. **先定性**:把问题归到"高并发 / 高可用 / 高性能"哪一类,明确它问的是"量、稳、快"中的哪一个。 2. **给结论再展开**:先用一句话给总纲(如"分层防御,每层独立限流降级"),再逐层讲方案。 3. **报数字**:用具体量级支撑观点(单台 Nginx 约 10~15 万 QPS、Redis 单节点约 10 万 QPS、雪花算法约 409.6 万/s/台等),让回答有说服力。 4. **补取舍与生产经验**:说明为什么这样设计、替代方案是什么、代价是什么,并给出"症状 → 原因 → 解决"的排查思路。 **高频追问速查表**(一句话回答,面试前扫一遍): | 追问 | 一句话回答 | |------|-----------| | **100万QPS怎么扛?** | CDN→Nginx→网关→服务四级分层,动静分离,异步化写操作 | | **热点Key打爆Redis怎么办?** | 多级缓存(本地Caffeine+Redis),热点自动发现+隔离到独立集群 | | **雪花算法时钟回拨?** | <5ms等待重试,>5ms抛异常告警,生产用百度UidGenerator | | **分布式ID用哪个?** | 雪花(无依赖)或美团Leaf号段(有DB运维能力) | | **MQ堆积百万条?** | 紧急扩容消费者+新建Topic分流+积压消息批量聚合 | | **怎么做到99.99%?** | 同城双活(秒级切换),两地三中心做灾备,混沌工程验证 | | **限流熔断降级区别?** | 限流=景区限流,熔断=保险丝断了,降级=保核心砍非核心 | | **灰度发布怎么做?** | 网关流量染色+标签路由,按UID哈希分流,全链路透传标签 | | **监控告警怎么做?** | 四大黄金指标(Metrics/Logs/Traces)+告警降噪+on-call升级 | | **深分页怎么优化?** | 游标分页(首选),覆盖索引+子查询(退而求其次),ES search_after(搜索场景) | | **接口2s→50ms怎么做?** | 缓存→异步并行→批量→覆盖索引→连接池调优,逐层递进 | | **全链路压测怎么搞?** | 流量染色+影子库(DB/Redis/MQ全隔离)+ThreadLocal全链路透传 | | **JVM怎么调优?** | 4G+用G1、堆对等、控制晋升、看GC日志定位、jstat+MAT分析 | | **什么时候用G1/ZGC?** | G1:<16G通用; ZGC:>16G且STW<10ms; JDK21+分代ZGC | | **线上OOM怎么排查?** | -XX:+HeapDumpOnOutOfMemoryError → MAT分析 → 大对象/ThreadLocal泄漏/直接内存 | | **系统突然变慢怎么排查?** | 看监控(CPU/内存/GC/线程池) → 链路追踪定位慢调用 → 日志查异常 | | **如何保证平稳上线?** | 灰度发布(1%→10%→50%→100%)+监控对比+秒级回滚能力 | | **什么是可观测性?** | Metrics(告警)+Logs(排错)+Traces(定位)三支柱,OpenTelemetry统一标准 | ### Q:三个维度各自的排查与优化顺序是什么? **高并发:先把入口守住,再谈吞吐。** 1. 入口限流(CDN/Nginx/网关/服务四层)——先保证不被打垮,能拒的请求尽早拒; 2. 缓存(多级)——把能提前算的、能复用的结果挡在 DB 前面; 3. 异步削峰(MQ + 生产者限流 + 消费者背压)——把"峰值"摊平成"均值"; 4. 水平扩容(无状态化 + 动态扩缩)——扩容是最后手段,不是第一手段。 **高可用:先发现、再定位、后止损、最后复盘。** 1. 发现:监控告警(黄金四指标)比用户更早发现问题; 2. 定位:链路追踪(Traces)找到出问题的环节,日志(Logs)确认根因; 3. 止损:限流 → 降级 → 熔断 → 故障转移(切机房/切数据源); 4. 复盘:确认是否需要容灾演练、混沌工程来验证修复。 **高性能:按收益从高到低逐层做,先定位瓶颈再动手。** 1. 定位:APM(如 SkyWalking)看耗时分布,GC 日志 + dump 看内存; 2. 缓存(收益最大,代价是一致性); 3. 异步 / 并行(注意线程池隔离,别打爆公共池); 4. 批量查询(消除 N+1); 5. 索引 / SQL(覆盖索引、只查必要字段、游标分页); 6. 连接池与 JVM(连接复用、GC 选型、堆与晋升控制)。 **通用原则**:不要过早优化;扩容前先问"瓶颈在哪";每一项优化都问自己"收益多大、代价是什么、能不能回滚"。 --- ## 自测 1. 用一句话分别说清高并发、高可用、高性能的区别,并说出 QPS、可用性、P99 三个指标各自衡量什么。 2. 单台 Nginx 大概能扛多少 QPS?要支撑 100 万 QPS,为什么要用 LVS + 多台 Nginx 的组合? 3. 热点 Key 把单个 Redis 节点打爆,你有哪些手段?滑动窗口发现、多级缓存、热点隔离分别解决了哪一段问题? 4. 雪花算法的 64 位是怎么划分的?出现时钟回拨时,5ms 以内和超过 5ms 分别怎么处理?为什么用雪花生成的订单号是趋势递增但不连续? 5. MQ 削峰时,为什么"生产者限流"通常优于"让 MQ 无限堆积"?消费者背压是怎么实现的? 6. 同城双活和两地三中心在 RTO/RPO 上分别是什么量级?MySQL 半同步复制为什么能做到不丢数据,代价是什么? 7. 限流、熔断、降级分别在保护谁?熔断状态机 CLOSED → OPEN → HALF_OPEN 的转换条件是什么?HALF_OPEN 默认放几个探测请求? 8. 灰度发布和蓝绿部署的核心区别是什么?如果新版本改了表结构,灰度期间数据库该怎么处理? 9. 深分页为什么慢?游标分页和"覆盖索引 + 子查询"分别适合什么场景?ES 的 search_after 解决的是什么问题? 10. 一个接口 P99 是 2000ms,你会按什么顺序优化到 50ms 以内?为什么加了并行之后还可能达不到目标? 11. 全链路压测里,流量染色标记为什么必须全链路透传?ThreadLocal 在哪些场景下会丢标记? 12. 4C8G 的订单服务频繁 Full GC,你会怎么排查?G1 和 ZGC 分别适合什么堆大小与延迟目标?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入