面试速查:Redis 与 Kafka 中间件

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
面向岗位:大型加密货币交易所 Senior Backend Developer - Risk 考察目标:Redis 和 Kafka 是 Senior Backend 面试中占比最高的中间件,通常占 25%-35%。本文档覆盖核心原理、手写代码、线上排障、以及 Risk/Fraud 场景落地。
目录
- 核心速查表
- 1.1 Redis 核心速查
- 1.2 Kafka 核心速查
- 手写代码精讲
- 2.1 手写 Redis 分布式锁
- 2.2 手写 Kafka Consumer 位移管理模型
- 2.3 手写消息幂等处理器
- 高频面试题库
- 面试现场建议
- 常见追问应对
1. 核心速查表
1.1 Redis 核心速查
数据结构时间复杂度
| 数据结构 | 典型命令 | 时间复杂度 | 底层实现 |
|---|---|---|---|
| String | GET/SET/INCR | O(1) | SDS (Simple Dynamic String) |
| Hash | HGET/HSET | O(1) | ziplist (小) / hashtable (大) |
| List | LPUSH/RPOP/LRANGE | O(1)/O(1)/O(N) | quicklist (ziplist 链表) |
| Set | SADD/SISMEMBER | O(1) | intset (小) / hashtable (大) |
| ZSet | ZADD/ZRANGE/ZRANGEBYSCORE | O(logN) | ziplist (小) / skiplist + hashtable (大) |
| Bitmap | SETBIT/GETBIT/BITCOUNT | O(1)/O(1)/O(N) | 底层是 String (SDS) |
| HyperLogLog | PFADD/PFCOUNT | O(1) | 稀疏/密集编码,12KB 固定空间 |
| Geo | GEOADD/GEORADIUS | O(logN)/O(N) | 底层 ZSet,score = geohash |
| Stream | XADD/XREAD/XGROUP | O(1) | Rax 树 + listpack |
持久化:RDB vs AOF
| 维度 | RDB | AOF |
|---|---|---|
| 原理 | 快照,定时 fork 子进程 dump | 追加写操作日志 |
| 文件体积 | 紧凑,经压缩 | 较大,可重写压缩 |
| 恢复速度 | 快(直接加载二进制) | 慢(重放命令) |
| 数据安全 | 可能丢最后一次快照后的数据 | always 几乎不丢,everysec 丢 1 秒 |
| 性能影响 | fork 时阻塞主线程(大内存时明显) | 持续写盘,everysec 性能好 |
| 重写机制 | 无 | BGREWRITEAOF,fork 子进程重写 |
生产配置:
appendonly yes+appendfsync everysec+ 定期BGSAVE。Redis 4.0+ 支持 混合持久化(RDB + AOF):先 RDB 全量,再 AOF 增量。
高可用方案对比
| 方案 | 架构 | 自动故障转移 | 数据分片 | 适用场景 |
|---|---|---|---|---|
| 主从复制 | 1主N从 | ❌ 手动 | ❌ | 读写分离,非关键数据 |
| Sentinel | 主从 + Sentinel 监控 | ✅ | ❌ | 中小规模,高可用 |
| Cluster | 多主多从,16384 slots | ✅ | ✅ | 大规模,海量数据 |
Cluster 分片:
CRC16(key) % 16384映射到 slot,slot 再映射到节点。节点间通过 Gossip 协议交换状态。
缓存问题三件套
| 问题 | 现象 | 解决方案 |
|---|---|---|
| 缓存穿透 | 查询不存在的数据,直接打到 DB | 1. 布隆过滤器预拦截;2. 缓存空值(null 或特殊标记),设短 TTL |
| 缓存击穿 | 热点 key 过期瞬间,大量请求打到 DB | 1. 互斥锁:只有一个线程去加载 DB;2. 逻辑过期:不设物理 TTL,用逻辑时间戳判断 |
| 缓存雪崩 | 大量 key 同时过期,DB 压力激增 | 1. 过期时间加随机偏移;2. 多级缓存(本地 + Redis);3. 熔断降级 |
内存淘汰策略(maxmemory-policy)
| 策略 | 行为 |
|---|---|
noeviction | 不淘汰,写操作直接报错(默认) |
allkeys-lru | 所有 key 中淘汰最近最少使用 |
allkeys-lfu | 所有 key 中淘汰使用频率最低 |
volatile-lru | 只淘汰设了 TTL 的 key,LRU |
volatile-lfu | 只淘汰设了 TTL 的 key,LFU |
allkeys-random | 所有 key 中随机淘汰 |
volatile-random | 有 TTL 的 key 中随机淘汰 |
volatile-ttl | 淘汰即将过期的 key |
大型加密货币交易所 推荐:
allkeys-lru(缓存场景)或volatile-lru(缓存+持久化混合)。Redis 4.0+ 的 LFU 更精确,适合冷热点分明的场景。
Redis 单线程模型为什么还这么快?
- 纯内存操作:所有数据在内存,无磁盘 I/O
- 单线程避免上下文切换:没有多线程的竞争、锁、上下文切换开销
- 高效数据结构:SDS、ziplist、skiplist、intset 都经过精心优化
- I/O 多路复用:基于 epoll(Linux)/ kqueue(macOS),单线程处理数万连接
- 避免系统调用:RDB fork 用 copy-on-write,AOF 用内存缓冲区批量刷盘
注意:Redis 6.0+ 引入多线程 I/O(
io-threads-do-reads yes),但只有网络读写是多线程,命令执行仍是单线程。
1.2 Kafka 核心速查
Kafka 架构速查
Producer ──→ Kafka Cluster (Brokers) ──→ Consumer Group
│ │
┌────┴────┐ ┌──┴────┐
│Broker 1 │ │Broker 2│ ...
│ ┌───┐ │ │ ┌───┐ │
│ │P0 │ │ │ │P1 │ │ (Partitions)
│ │P2 │ │ │ │P3 │ │
│ └───┘ │ │ └───┘ │
│ Leader/Follower │
└─────────┘ └────────┘
↑
Controller (管理分区 Leader 选举)
KRaft (Kafka 3.0+ 替代 ZooKeeper)
核心概念
| 概念 | 定义 |
|---|---|
| Topic | 逻辑消息分类,如 risk-events |
| Partition | Topic 的物理分片,每个 partition 是一个有序、不可变的日志 |
| Offset | 消息在 partition 内的唯一标识(递增 long) |
| Replica | 分区副本,Leader 处理读写,Follower 同步 |
| ISR | In-Sync Replicas:与 Leader 数据同步的副本集合 |
| AR | Assigned Replicas:该分区的所有副本 |
| HW (High Watermark) | ISR 中所有副本都已复制的最大 offset,消费者只能读到 HW |
| LEO (Log End Offset) | 分区当前最后一条消息的 offset + 1 |
| Consumer Group | 一组消费者共同消费一个 topic,partition 只能被 group 内一个 consumer 消费 |
Kafka 高性能原理
| 技术 | 原理 | 效果 |
|---|---|---|
| 顺序写盘 | 分区日志追加写,磁盘顺序写速度 ≈ 内存随机写 | 磁盘吞吐媲美内存 |
| Page Cache | 利用 OS 的 page cache,读写先走内存 | 零内核态开销 |
| 零拷贝(Zero-Copy) | sendfile() 直接 DMA 从 page cache 到网卡 | 省去用户态 buffer,CPU 占用降低 |
| 批量压缩 | Producer 批量发送,消息压缩(gzip/snappy/lz4/zstd) | 网络带宽降低 70%+ |
| 分区并行 | 一个 topic 多个 partition,天然水平扩展 | 线性扩展吞吐 |
ACK 机制与消息可靠性
| acks | 行为 | 吞吐 | 数据安全 |
|---|---|---|---|
acks=0 | 发完不管,不等待确认 | 最高 | 最不安全,可能丢消息 |
acks=1 | 等 Leader 确认 | 中 | Leader 宕机,未同步到 Follower 的消息丢失 |
acks=all | 等 ISR 中所有副本确认 | 最低 | 最安全,只要 ISR 中一个存活就不丢 |
幂等性(Idempotent Producer):
enable.idempotence=true,Producer 给每条消息分配 PID + Sequence Number,Broker 去重。解决单分区内的重复。 事务(Transactions):transactional.id,跨分区原子写入。配合 consumer 的isolation.level=read_committed实现 Exactly-Once。
Consumer Rebalance
触发条件:
- Consumer Group 内成员变化(新 consumer 加入 / 离开 / 崩溃)
- Topic 的 partition 数变化
- 消费者主动调用
unsubscribe()
Rebalance 协议:
- Eager Rebalance(默认):停止所有消费,重新分配所有 partition,再恢复。存在停止世界问题。
- Cooperative Rebalance(Kafka 2.4+,
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor):增量 rebalance,只迁移需要调整的 partition,减少停顿。
分区分配策略:
| 策略 | 原理 | 特点 |
|---|---|---|
| Range | 按 topic 范围分配 | 默认,可能不均匀 |
| RoundRobin | 轮询分配所有 partition | 均匀,但 rebalance 时变动大 |
| Sticky | 尽量保持现有分配,新 consumer 从最多处取 | 推荐,rebalance 代价最小 |
| CooperativeSticky | Sticky 的增量版本 | Kafka 2.4+ 推荐 |
2. 手写代码精讲
2.1 手写 Redis 分布式锁
题目
实现一个基于 Redis 的分布式锁,支持 lock()、unlock(),处理原子性、锁续期、可重入。
核心思路
- 加锁原子性:
SET key value NX EX 30(Redis 2.6.12+ 的SET扩展),一条命令完成 set + nx + expire - 防误删:value = 随机 token(如 UUID),解锁时用 Lua 脚本检查 token 是否匹配再删除
- 锁续期(Watch Dog):加锁后启动守护线程,每 10 秒检查锁是否还在,如果在则续期(类似 Redisson 的看门狗)
- 可重入:value 用
线程ID:重入次数格式,同线程重复加锁时计数 +1
Java 实现
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.params.SetParams;
import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 基于 Redis 的分布式锁(简化版 Redisson 原理)。
* 特性:原子加锁、Lua 解锁、看门狗续期、可重入。
*/
public class RedisDistributedLock {
private final JedisPool jedisPool;
private final String lockKey;
private final int expireSeconds;
private final String lockValue;
private final AtomicInteger reentrantCount = new AtomicInteger(0);
private ScheduledExecutorService watchDog;
private volatile boolean locked = false;
private static final String UNLOCK_SCRIPT =
"if redis.call('get', KEYS[1]) == ARGV[1] then " +
" return redis.call('del', KEYS[1]) " +
"else " +
" return 0 " +
"end";
public RedisDistributedLock(JedisPool jedisPool, String lockKey, int expireSeconds) {
this.jedisPool = jedisPool;
this.lockKey = lockKey;
this.expireSeconds = expireSeconds;
this.lockValue = UUID.randomUUID().toString() + ":" + Thread.currentThread().getId();
}
/**
* 尝试加锁,非阻塞。
*/
public boolean tryLock() {
if (reentrantCount.get() > 0) {
reentrantCount.incrementAndGet();
return true;
}
try (Jedis jedis = jedisPool.getResource()) {
SetParams params = new SetParams();
params.nx().ex(expireSeconds);
String result = jedis.set(lockKey, lockValue, params);
if ("OK".equals(result)) {
locked = true;
reentrantCount.set(1);
startWatchDog();
return true;
}
return false;
}
}
/**
* 阻塞加锁,带超时。
*/
public boolean lock(long waitTimeMillis) throws InterruptedException {
long deadline = System.currentTimeMillis() + waitTimeMillis;
while (System.currentTimeMillis() < deadline) {
if (tryLock()) {
return true;
}
Thread.sleep(100);
}
return false;
}
public void unlock() {
if (reentrantCount.get() > 1) {
reentrantCount.decrementAndGet();
return;
}
try (Jedis jedis = jedisPool.getResource()) {
Object result = jedis.eval(UNLOCK_SCRIPT,
Collections.singletonList(lockKey),
Collections.singletonList(lockValue));
if (result != null && (Long) result == 1L) {
locked = false;
reentrantCount.set(0);
stopWatchDog();
}
}
}
private void startWatchDog() {
watchDog = Executors.newSingleThreadScheduledExecutor(r -> {
Thread t = new Thread(r);
t.setName("watchdog-" + lockKey);
t.setDaemon(true);
return t;
});
// 每 1/3 过期时间续期一次
long renewInterval = expireSeconds * 1000L / 3;
watchDog.scheduleAtFixedRate(() -> {
if (!locked) {
return;
}
try (Jedis jedis = jedisPool.getResource()) {
String currentValue = jedis.get(lockKey);
if (lockValue.equals(currentValue)) {
jedis.expire(lockKey, expireSeconds);
}
} catch (Exception e) {
// 续期失败,锁会自然过期,业务需处理超时
}
}, renewInterval, renewInterval, TimeUnit.MILLISECONDS);
}
private void stopWatchDog() {
if (watchDog != null) {
watchDog.shutdownNow();
}
}
// ===================== 测试代码 =====================
public static void main(String[] args) throws Exception {
// 需要本地 Redis,或用嵌入式 Redis 测试
// JedisPool pool = new JedisPool("localhost", 6379);
// RedisDistributedLock lock = new RedisDistributedLock(pool, "order:lock:123", 10);
// boolean acquired = lock.tryLock();
// System.out.println("Lock acquired: " + acquired);
// Thread.sleep(5000);
// lock.unlock();
// System.out.println("Lock released");
}
}复杂度分析
| Operation | 时间 | 说明 |
|---|---|---|
tryLock | O(1) | 单次 Redis SET NX EX |
unlock | O(1) | Lua 脚本原子执行 |
lock(wait) | O(等待轮次) | 轮询间隔 100ms |
| WatchDog 续期 | O(1) | 后台定时任务 |
易错点
- 不要用
SETNX + EXPIRE两条命令:中间如果进程崩溃,锁永不过期(死锁)。必须用SET NX EX一条命令。 - 解锁必须检查 value:防止 A 的锁过期后,B 获取锁,A 执行完却删了 B 的锁。
- 续期失败的处理:如果 Redis 网络抖动,续期失败,锁会在
expireSeconds后自动释放。业务逻辑必须能在锁超时后幂等或回滚。 - 可重入的线程安全:
reentrantCount是 JVM 内存变量,只对本实例有效。不同 JVM 实例上的同线程 ID 不算重入。
大型加密货币交易所 / Risk 实际应用
- 风控规则互斥执行:同一用户的规则评估任务,通过
userId加锁,避免并发评估导致状态错乱。 - 每日对账任务:凌晨调度器触发对账,分布式锁保证只有一个节点执行。
- 制裁名单更新:OFAC 名单更新时加全局锁,防止多个节点同时更新缓存。
2.2 手写 Kafka Consumer 位移管理模型
题目
实现一个简化版 Kafka Consumer 的位移管理器,支持自动提交和手动提交,处理**再均衡(Rebalance)**时的位移安全。
核心思路
- Offset 存储:Kafka 内部 topic
__consumer_offsets(Kafka 0.9+ 默认),或外部存储(如 Redis / MySQL) - 自动提交:
enable.auto.commit=true,poll 后按auto.commit.interval.ms定时提交。简单但可能丢消息(已消费未提交时崩溃)。 - 手动同步提交:
consumer.commitSync(),消费完一批后同步提交,失败可重试。 - 手动异步提交:
consumer.commitAsync(callback),不阻塞消费,但可能提交乱序。 - 再均衡时保存 offset:通过
ConsumerRebalanceListener的onPartitionsRevoked()在 rebalance 前同步提交当前 offset。
Java 实现
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import java.time.Duration;
import java.util.*;
/**
* 手动提交 + Rebalance 安全偏移量管理的 Kafka Consumer。
*/
public class SafeOffsetConsumer {
private final KafkaConsumer<String, String> consumer;
private final Map<TopicPartition, Long> pendingOffsets = new HashMap<>();
private volatile boolean running = true;
public SafeOffsetConsumer(String bootstrapServers, String groupId, String topic) {
Properties props = new Properties();
props.put("bootstrap.servers", bootstrapServers);
props.put("group.id", groupId);
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
// 关闭自动提交
props.put("enable.auto.commit", "false");
// 消费策略:earliest(从最早)或 latest(从最新)
props.put("auto.offset.reset", "earliest");
this.consumer = new KafkaConsumer<>(props);
this.consumer.subscribe(Collections.singletonList(topic), new RebalanceListener());
}
public void run() {
try {
while (running) {
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : records) {
process(record);
// 记录已处理的 offset(注意:offset 是下次应该消费的位置)
TopicPartition tp = new TopicPartition(record.topic(), record.partition());
pendingOffsets.put(tp, record.offset() + 1);
}
// 批量提交:每处理完一批,同步提交
if (!pendingOffsets.isEmpty()) {
commitOffsets();
}
}
} finally {
// 关闭前再提交一次
commitOffsets();
consumer.close();
}
}
private void process(ConsumerRecord<String, String> record) {
// 实际业务处理
System.out.printf("Processing: topic=%s, partition=%d, offset=%d, key=%s, value=%s%n",
record.topic(), record.partition(), record.offset(), record.key(), record.value());
}
private void commitOffsets() {
try {
Map<TopicPartition, OffsetAndMetadata> offsetsToCommit = new HashMap<>();
for (Map.Entry<TopicPartition, Long> entry : pendingOffsets.entrySet()) {
offsetsToCommit.put(entry.getKey(), new OffsetAndMetadata(entry.getValue()));
}
consumer.commitSync(offsetsToCommit);
pendingOffsets.clear();
} catch (Exception e) {
// 提交失败,下次继续尝试,不清理 pendingOffsets
System.err.println("Commit failed: " + e.getMessage());
}
}
public void shutdown() {
running = false;
}
/**
* Rebalance 监听器:在分区被回收前提交当前 offset。
*/
private class RebalanceListener implements ConsumerRebalanceListener {
@Override
public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
System.out.println("Partitions revoked: " + partitions);
// Rebalance 前必须同步提交!否则新 consumer 会从旧 offset 开始,导致重复消费
commitOffsets();
}
@Override
public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
System.out.println("Partitions assigned: " + partitions);
// 可以在这里 seek 到特定 offset,实现"从失败点重试"
for (TopicPartition tp : partitions) {
Long offset = loadOffsetFromExternalStore(tp);
if (offset != null) {
consumer.seek(tp, offset);
}
}
}
}
// 模拟外部存储(如 MySQL / Redis)
private Long loadOffsetFromExternalStore(TopicPartition tp) {
// 实际生产环境从外部存储读取
return null;
}
// ===================== 测试代码 =====================
public static void main(String[] args) {
// 需要本地 Kafka 环境
// SafeOffsetConsumer consumer = new SafeOffsetConsumer("localhost:9092", "risk-group", "risk-events");
// consumer.run();
}
}复杂度分析
| Operation | 时间 | 说明 |
|---|---|---|
poll | O(1) | 从本地 buffer 取数据 |
commitSync | O(N) | N = 提交的 partition 数,网络 RTT |
seek | O(1) | 修改本地 offset 指针 |
易错点
commitSync的 offset 是"下一条":record.offset() + 1,不是当前消息的 offset。Kafka 记录的是下一次应该从哪消费。- Rebalance 前必须
commitSync:onPartitionsRevoked里用异步提交可能导致提交失败未被感知,rebalance 后重复消费。 - 不要在
onPartitionsAssigned里做重初始化:如果耗时操作放在这里,会阻塞 rebalance 协议,导致 coordinator 认为 consumer 死亡,触发新一轮 rebalance。
大型加密货币交易所 / Risk 实际应用
- 实时风控事件消费:
risk-eventstopic 的 consumer group,手动提交保证每条事件处理完再 commit,失败时从外部存储的 checkpoint 恢复。 - 交易对账消息:消费交易流水,处理完写 MySQL 后再 commit,保证"至少一次"且通过幂等保证"实际一次"。
- 制裁名单变更通知:Kafka 通知各节点刷新缓存,手动提交 + 外部存储 offset,确保不遗漏通知。
2.3 手写消息幂等处理器
题目
实现一个消息消费的幂等处理器,基于 Redis + MySQL 双写,处理 Kafka 消息的**至少一次(At-Least-Once)**语义下的重复消费。
核心思路
- 唯一键:每条消息生成唯一 ID(
topic + partition + offset或业务唯一键如orderId) - Redis 去重:
SETNX msg_id 1 EX 86400,设置成功说明是首次消费,继续处理;失败说明已消费,直接丢弃 - MySQL 去重:业务表加唯一索引(
UNIQUE KEY uk_msg_id (msg_id)),插入时捕获DuplicateKeyException - Redis 为主,MySQL 为兜底:Redis 性能高但可能丢数据(持久化异常时),MySQL 唯一索引是最终一致性保障
- 双写原子性:先写 Redis(SETNX),再写 MySQL(INSERT)。如果 Redis 成功、MySQL 失败,Redis 的 key 会自然过期,不影响;如果 Redis 失败(已存在),直接返回幂等。
Java 实现
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.sql.*;
import java.util.UUID;
/**
* 消息幂等处理器:Redis SETNX + MySQL 唯一索引。
* 适用于 Kafka At-Least-Once 语义下的重复消费防护。
*/
public class IdempotentMessageProcessor {
private final JedisPool jedisPool;
private final Connection dbConnection;
private final int redisTtlSeconds;
public IdempotentMessageProcessor(JedisPool jedisPool,
Connection dbConnection,
int redisTtlSeconds) {
this.jedisPool = jedisPool;
this.dbConnection = dbConnection;
this.redisTtlSeconds = redisTtlSeconds;
}
/**
* 处理消息,保证幂等。
*
* @param msgId 消息唯一标识(如 topic + partition + offset,或业务唯一键)
* @param msgPayload 消息内容
* @return true=首次处理成功, false=重复消息已丢弃
*/
public boolean process(String msgId, String msgPayload) {
// Step 1: Redis SETNX 去重(第一层防护)
if (!tryRedisDedup(msgId)) {
System.out.println("Duplicate message filtered by Redis: " + msgId);
return false;
}
// Step 2: 业务处理 + MySQL 幂等(第二层防护)
try {
return processWithDb(msgId, msgPayload);
} catch (Exception e) {
// 业务处理失败:Redis 已写,但业务未成功
// 下次重试时,Redis 会拦住(如果是同一 msgId)
// 但如果 Redis TTL 短,可能穿透到 DB,此时 DB 唯一索引会拦住
System.err.println("Processing failed, msgId=" + msgId + ", error=" + e.getMessage());
throw new RuntimeException("Processing failed", e);
}
}
private boolean tryRedisDedup(String msgId) {
try (Jedis jedis = jedisPool.getResource()) {
String dedupKey = "dedup:" + msgId;
Long result = jedis.setnx(dedupKey, "1");
if (result == 1) {
jedis.expire(dedupKey, redisTtlSeconds);
return true;
}
return false;
}
}
private boolean processWithDb(String msgId, String msgPayload) throws SQLException {
// 开启事务
dbConnection.setAutoCommit(false);
try {
// 先插入幂等记录表(有唯一索引)
String insertDedupSql = "INSERT INTO idempotent_log (msg_id, status, created_at) VALUES (?, 'PROCESSING', NOW())";
try (PreparedStatement ps = dbConnection.prepareStatement(insertDedupSql)) {
ps.setString(1, msgId);
ps.executeUpdate();
}
// 执行业务逻辑(如更新订单状态)
doBusinessLogic(msgPayload);
// 更新幂等记录为成功
String updateSql = "UPDATE idempotent_log SET status = 'SUCCESS' WHERE msg_id = ?";
try (PreparedStatement ps = dbConnection.prepareStatement(updateSql)) {
ps.setString(1, msgId);
ps.executeUpdate();
}
dbConnection.commit();
return true;
} catch (SQLIntegrityConstraintViolationException e) {
// 唯一索引冲突:消息已处理过
dbConnection.rollback();
System.out.println("Duplicate message filtered by DB unique index: " + msgId);
return false;
} catch (Exception e) {
dbConnection.rollback();
throw e;
} finally {
dbConnection.setAutoCommit(true);
}
}
private void doBusinessLogic(String msgPayload) {
// 实际业务处理
System.out.println("Processing business logic for: " + msgPayload);
}
// ===================== 测试代码 =====================
public static void main(String[] args) throws Exception {
// JedisPool pool = new JedisPool("localhost", 6379);
// Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/test", "user", "pass");
// IdempotentMessageProcessor processor = new IdempotentMessageProcessor(pool, conn, 86400);
//
// String msgId = "topic-0-12345";
// boolean r1 = processor.process(msgId, "order:123:PAID");
// boolean r2 = processor.process(msgId, "order:123:PAID"); // 重复
// System.out.println("First: " + r1 + ", Second: " + r2);
}
}复杂度分析
| Operation | 时间 | 说明 |
|---|---|---|
| Redis SETNX | O(1) | 网络 RTT |
| DB INSERT | O(1) | 唯一索引查询 |
| 总耗时 | ~2 RTT | Redis + DB |
易错点
- Redis 和 DB 不是原子操作:Redis SETNX 成功、DB 失败时,Redis 已记录但业务未成功。重试时 Redis 会拦住(如果 TTL 没过)。如果 TTL 过了,DB 唯一索引是兜底。
- 事务隔离级别:DB 事务必须是
READ COMMITTED以上,否则幻读可能导致重复插入。 - 清理策略:幂等表会无限增长,需定期归档或设 TTL(如 30 天后删除)。
- 分布式事务:如果需要 Redis + DB 强一致,用 TCC 或 Saga,但复杂度极高。多数场景下两层防护足够。
大型加密货币交易所 / Risk 实际应用
- 充值到账通知:Kafka 消费区块链充值事件,幂等处理防止重复入账。
- 风控规则触发动作:同一 risk event 只执行一次动作(如冻结账户、发告警),避免重复冻结。
- 制裁名单命中处理:命中 OFAC 名单后只触发一次拦截流程。
3. 高频面试题库
3.1 Redis 篇
Q1: Redis 是单线程的,为什么还支持高并发?瓶颈在哪?
标准答案:
Redis 的命令执行是单线程的,但网络 I/O 在 6.0+ 支持多线程。
高并发原因:
- 纯内存操作:无磁盘 I/O,内存访问 ns 级
- 高效数据结构:SDS、ziplist、skiplist、dict 都经过优化
- I/O 多路复用:单线程通过 epoll 管理数万连接,没有线程切换开销
- 避免锁竞争:单线程天然无锁,没有上下文切换和 cache line 竞争
瓶颈:
- 大 key 操作:
HGETALL一个百万 field 的 hash,LRANGE百万元素的 list,会阻塞整个实例- 复杂命令:
KEYS *、SORT、SUNION等 O(N) 命令- 持久化 fork:BGSAVE / AOF rewrite 时 fork 子进程,大内存下 fork 耗时可达秒级,阻塞主线程
- 内存上限:单实例内存不宜超过 20-30GB(fork 时间、故障恢复时间)
- 网络带宽:零拷贝也受限于网卡带宽
易错点:
- 不要说 "Redis 多线程所以高并发",核心原因是单线程 + 内存 + I/O 多路复用。
- 也不要说 "Redis 完全单线程",6.0+ 的 I/O 是多线程的。
Q2: Redis 的大 Key 和热 Key 怎么发现和解决?
标准答案:
发现大 Key:
redis-cli --bigkeys:扫描全库,统计每种类型最大的 keyMEMORY USAGE key:精确查看单个 key 的内存占用RDB Tools(rdbtools / redis-rdb-tools):分析 RDB 文件,离线统计大 key- 监控
INFO COMMANDSTATS:找出执行慢命令的 key解决大 Key:
- 拆分:大 hash 拆成多个小 hash(如
user:1000拆成user:1000:profile、user:1000:settings)- 压缩:value 用 protobuf / msgpack 替代 JSON
- 异步删除:Redis 4.0+ 用
UNLINK替代DEL,后台线程释放内存发现热 Key:
MONITOR命令实时抓流量(生产环境慎用,性能影响大)redis-cli --hotkeys(需要配置maxmemory-policy为 LFU)- 业务层埋点统计 key 访问频率
- 代理层(如 Twemproxy / Codis)统计
解决热 Key:
- 本地缓存:本地 Caffeine / Guava Cache 做 L1,Redis 做 L2
- key 拆分:热 key 加随机后缀(如
config:v1、config:v2),分散到多个 key- 读写分离:从节点分担读压力
- Proxy 层限流:对单个 key 的 QPS 限流
易错点:
redis-cli --bigkeys是扫描全库,大 key 多的情况下会阻塞生产实例。建议在 slave 上执行或低峰期执行。- 本地缓存解决热 key 时,要注意数据一致性和缓存失效广播。
Q3: Redis Cluster 模式下,一个请求是怎么路由到正确节点的?
标准答案:
- 计算 slot:
slot = CRC16(key) % 16384- 查找节点:客户端维护
slot -> node的映射表(cluster slots 命令获取)- 发送请求:直接发送到目标节点
- MOVED 重定向:如果 key 已迁移(resharding),目标节点返回
MOVED slot new_node_ip:port,客户端更新映射表并重试- ASK 重定向:如果 slot 正在迁移中(源节点还有部分 key),返回
ASK slot importing_node_ip:port,客户端发送ASKING命令后重试Smart Client(如 JedisCluster、Lettuce):
- 启动时通过
CLUSTER SLOTS获取全部分区映射- 维护本地缓存,减少重定向
- 定期刷新拓扑(如节点变化时)
易错点:
- mget / mset 跨 slot:如果多个 key 不在同一个 slot,Redis Cluster 的
MGET会报错。解决方案:- 用 hash tag:
{user}:1000:name和{user}:1000:age,{}内参与 CRC16 计算,保证同 slot - 客户端分片后分别请求再合并(如 Lettuce 的
mget自动处理)
- 用 hash tag:
- 事务(MULTI)跨 slot:
WATCH/MULTI/EXEC的所有 key 必须在同一个 slot。
Q4: 缓存和数据库一致性问题怎么解决?
标准答案:
方案对比:
方案 实现 优点 缺点 Cache Aside 读:先读缓存,miss 读 DB 写缓存;写:先写 DB,再删缓存 简单,最常用 极端情况下短暂不一致 Read/Write Through 读写都走缓存,缓存负责同步 DB 对应用透明 缓存组件复杂(如 Redis 做不到) Write Behind 先写缓存,异步写 DB 写性能极高 数据丢失风险大 Cache Aside 详解(最常用):
- 读:先读 Redis,命中直接返回;miss 读 MySQL,写回 Redis
- 写:先更新 MySQL,再删除 Redis(不是更新!)
- 为什么删不是更新?因为并发写时,两个线程写 DB 的顺序和写缓存的顺序可能颠倒,导致缓存脏数据更久
- 删除后下次读会自动从 DB 加载最新值
双写不一致的极端情况:
- 线程 A 读缓存 miss,读 DB 得到旧值 v1
- 线程 B 写 DB 为 v2,删缓存
- 线程 A 把 v1 写回缓存
- 结果:缓存是 v1(旧),DB 是 v2(新)
解决方案:
- 延时双删:写操作先删缓存 -> 写 DB -> 睡眠 200ms -> 再删缓存。降低不一致窗口
- 消息队列异步删:写 DB 后发 MQ,消费者异步删缓存。保证最终一致性
- ** canal + MQ**:监听 MySQL binlog,异步删缓存。对业务零侵入
- 设置短 TTL:让不一致数据自然过期
易错点:
- 不要先删缓存再写 DB。如果删完缓存后、写 DB 前,另一个线程读 miss 加载了旧值到缓存,就会不一致。
- 正确的顺序是:先写 DB,再删缓存。
- 延时双删的"睡眠"时间要大于一次读操作的耗时(通常 100-500ms)。
Q5: Redis 的过期删除策略是什么?
标准答案:
Redis 同时用两种策略:
- 惰性删除(Lazy Expiration):
- 访问 key 时检查是否过期,过期则删除
- 优点:不消耗 CPU
- 缺点:过期 key 如果不被访问,一直占内存
- 定期删除(Active Expiration):
- 每 100ms 随机抽查一批 key(默认 20 个),删除其中过期的
- 如果过期比例 > 25%,则继续抽查,但最多执行 25ms
- 优点:平衡 CPU 和内存
- 缺点:仍可能有漏网之鱼
内存淘汰策略兜底:当内存达到
maxmemory时,按配置的淘汰策略(LRU/LFU)清理。
易错点:
- Redis 的定期删除不是定时删除(不是到点就删),而是概率抽查。
- 大量 key 同时过期时,定期删除可能忙不过来,导致内存突增。解决:过期时间加随机偏移。
EXPIRE的底层是惰性 + 定期,不是精确计时器。
3.2 Kafka 篇
Q6: Kafka 的 ISR、HW、LEO 是什么?为什么消费者只能读到 HW?
标准答案:
- LEO(Log End Offset):分区最后一条消息的 offset + 1,表示下一条消息写入的位置。每个副本有自己的 LEO。
- HW(High Watermark):ISR 中所有副本的最小 LEO。消费者只能读到 HW 之前的消息。
- ISR(In-Sync Replicas):与 Leader 保持同步的副本集合。Follower 的 LEO 落后 Leader 不超过
replica.lag.time.max.ms(默认 10 秒)时,在 ISR 内。为什么消费者只能读到 HW? 为了保证一致性。如果消费者读到了 HW 之后的消息,而 Leader 宕机,新 Leader 可能没有这个消息(因为 ISR 中的 Follower 还没同步),导致已消费的消息"丢失"(消费者以为消费了,但实际消息在新 Leader 上不存在)。
Leader 宕机时的选举:
- Controller 从 ISR 中选新 Leader(第一个)
- 如果 ISR 全挂了,看
unclean.leader.election.enable:
false(默认):等 ISR 恢复,可用性降低但不丢消息true:从所有副本中选 LEO 最大的,可能丢消息但保证可用
易错点:
- HW 不是 Leader 的 LEO,而是ISR 中所有副本的最小 LEO。
acks=all+min.insync.replicas=2时,如果 ISR 只剩 1 个(Leader),Producer 会收到NOT_ENOUGH_REPLICAS异常。- Kafka 2.4+ 引入了 Leader Epoch 替代 HW 解决数据不一致问题(如 Leader 切换后的日志截断)。
Q7: Kafka 为什么性能这么高?零拷贝具体是怎么做的?
标准答案:
高性能四大支柱:
- 顺序写盘:传统数据库随机写慢,Kafka 追加写 log 文件,磁盘顺序写速度 ≈ 内存随机写
- Page Cache:OS 的 page cache 缓存磁盘数据,consumer 读消息时先读 page cache,命中则零磁盘 I/O
- 零拷贝(Zero-Copy):
- 传统方式:磁盘 -> 内核 buffer -> 用户 buffer -> Socket buffer -> 网卡(4 次拷贝,4 次上下文切换)
- Kafka 方式:磁盘 -> Page Cache ->
sendfile()DMA 到网卡(2 次拷贝,2 次上下文切换)- 如果 consumer 和 broker 在同一机器,直接从 page cache 读,0 次磁盘 I/O
- 批量与压缩:Producer 积累一批消息(
batch.size、linger.ms)后压缩发送,网络带宽降低 70%+零拷贝细节:
// Kafka 底层调用 Java NIO 的 transferTo FileChannel.transferTo(position, count, socketChannel); // 对应 Linux sendfile() 系统调用数据从 page cache 直接 DMA 到网卡 buffer,不经过 JVM 堆内存。
易错点:
- 零拷贝只在网络发送时有效(Producer -> Broker 或 Broker -> Consumer)。如果 Consumer 需要加工数据(如反序列化到 JVM 对象),数据还是要拷贝到用户态。
sendfile在 TLS/SSL 加密时失效(SSL 需要用户态加密),此时退化为传统拷贝。- Kafka 的零拷贝依赖 OS 的 page cache,所以不要给 Kafka 的 JVM 分配太多内存(通常 6-8GB 足够),留内存给 OS cache。
Q8: Kafka 消费组 Rebalance 是什么?怎么优化?
标准答案:
Rebalance:Consumer Group 内的 partition 重新分配给各个 consumer。触发条件:
- Group 内成员变化(加入/离开/崩溃)
- Topic 的 partition 数变化
- Consumer 调用
subscribe()/unsubscribe()Rebalance 的问题:
- 消费暂停:rebalance 期间整个 group 停止消费
- 重复消费:rebalance 前未提交的 offset,新 consumer 从旧 offset 开始消费
- 消费延迟:频繁 rebalance 导致消息积压
优化方案:
- 减少 Consumer 数量波动:
- 设置合理的
session.timeout.ms(默认 10s)和heartbeat.interval.ms(默认 3s)max.poll.interval.ms要大于业务处理时间,避免处理慢被踢出 group- 使用 Cooperative Rebalance(Kafka 2.4+):
- 配置
partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor- 增量 rebalance,只迁移需要调整的 partition
- Consumer Rebalance Listener:
onPartitionsRevoked()里同步提交 offsetonPartitionsAssigned()里恢复处理状态- 增加 partition 数:减少单个 consumer 负责的 partition 数,rebalance 时变动更小
- 避免频繁加入/退出:不要每次 poll 都
subscribe,consumer 应该是长连接
易错点:
max.poll.records设置太大,导致单次 poll 处理时间超过max.poll.interval.ms,consumer 被踢出触发 rebalance。session.timeout.ms和heartbeat.interval.ms的比例通常是 1:3。- Rebalance 期间,如果业务处理逻辑在
onPartitionsRevoked里耗时太长,会阻塞 rebalance 完成,导致 coordinator 超时。
Q9: Kafka 的 Exactly-Once 语义是怎么实现的?
标准答案:
Kafka 的 Exactly-Once 是端到端的,涉及三个环节:Producer -> Broker -> Consumer。
Producer 端:
- 幂等性 Producer:
enable.idempotence=true,Broker 去重
- 每条消息带
PID(Producer ID)+Sequence Number- Broker 按
(PID, Partition, SeqNum)去重- 局限:只保证单分区内不重复,跨 session 不保证(重启后 PID 会变)
- 事务 Producer:
transactional.id,跨分区原子写入
initTransactions()->beginTransaction()->send()->commitTransaction()- Broker 维护事务状态,保证原子性
Broker 端:
- 支持事务日志,记录事务的 commit/abort 状态
Consumer 端:
isolation.level=read_committed:只读取已提交的事务消息- 配合外部系统的幂等或事务(如 DB 事务),实现端到端 Exactly-Once
端到端 Exactly-Once 示例:
Producer(事务) -- Kafka --> Consumer -- 幂等写 DB或:
Producer(事务) -- Kafka --> Consumer -- DB 事务(消费 offset + 业务数据同一事务)
易错点:
- Kafka 的 Exactly-Once 是 "精确一次写入 Kafka",不是"精确一次处理"。Consumer 端的处理仍需业务自己保证幂等。
- 幂等 Producer 的 PID 在 Producer 重启后会变,所以跨重启的重复需要事务保证。
- 事务 Producer 有性能开销(约 10-20% 吞吐下降),只在强一致性场景使用。
Q10: Kafka vs RabbitMQ vs RocketMQ 怎么选?
标准答案:
| 维度 | Kafka | RabbitMQ | RocketMQ |
|---|---|---|---|
| 定位 | 高吞吐日志/事件流 | 通用消息队列 | 金融级可靠消息 |
| 吞吐 | 最高(百万级/s) | 万级/s | 十万级/s |
| 延迟 | ms 级(批量) | μs 级(单条) | ms 级 |
| 可靠性 | 高(副本 + acks) | 高(confirm + 持久化) | 最高(同步双写) |
| 顺序性 | 分区级顺序 | 队列级顺序 | 队列级顺序 |
| 事务 | 支持(跨分区) | 支持(AMQP) | 支持(分布式事务) |
| 延迟消息 | 需自行实现(TimeWheel) | 插件支持 | 原生支持 |
| 死信队列 | 需自行实现 | 原生支持 | 原生支持 |
| 社区 | 最大,Apache | 大,VMware | 阿里开源,中文社区强 |
| 运维复杂度 | 中(ZooKeeper/KRaft) | 低 | 中 |
选型建议:
- 日志采集、实时监控、事件流:Kafka(吞吐最高,生态最好)
- 低延迟 RPC 异步化、任务队列:RabbitMQ(延迟最低,路由灵活)
- 金融交易、分布式事务、延迟消息:RocketMQ(阿里金融场景打磨,可靠性最强)
大型加密货币交易所 场景:
- 风控实时事件流:Kafka(百万级 risk event/s,需要高吞吐)
- 交易通知、邮件/SMS 发送:RabbitMQ 或 RocketMQ(延迟敏感)
- 订单状态变更:RocketMQ(需要事务消息保证订单和消息一致性)
4. 面试现场建议
4.1 中间件题回答框架
面试中被问到 Redis/Kafka 原理时,按 "场景 -> 原理 -> 对比 -> 落地" 四层结构回答:
第一层:场景引入
"在 大型加密货币交易所 风控系统中,我们每日处理数千万级风险事件..."
第二层:原理解释
"Kafka 的高性能来自四点:顺序写、page cache、零拷贝、批量压缩..."
第三层:对比分析
"和 RabbitMQ 相比,Kafka 更适合高吞吐日志场景,但延迟更高..."
第四层:落地细节
"我们实际配置了 acks=all、min.insync.replicas=2、
partition 数 = consumer 数的 3 倍,保证..."
4.2 加分项关键词
| 话题 | 一句话表达 |
|---|---|
| Redis 6.0 多线程 I/O | "Redis 6.0 引入多线程 I/O,但命令执行仍是单线程,主要是为了榨干网卡带宽" |
| Redis 8.0 MPTCP | "Redis 8.0 实验性支持 MPTCP,多路径 TCP 提升网络吞吐" |
| Kafka KRaft | "Kafka 3.0+ 的 KRaft 模式去掉 ZooKeeper,元数据自管理,部署更简单" |
| Kafka Tiered Storage | "Kafka 3.0+ 支持分层存储,冷数据自动转到 S3,降低本地磁盘成本" |
| Redis 多活 | "Redis CRDT 或主主复制实现多活,大型加密货币交易所 全球多机房需要就近读取" |
| Kafka Consumer Group 静态成员 | "group.instance.id 让 consumer 重启后保持 partition 分配,避免 rebalance" |
4.3 避免的坑
- 不要混淆 Kafka 的 partition 和 replica:partition 是逻辑分片,replica 是物理副本。一个 partition 有多个 replica(Leader + Followers)。
- 不要说 Redis Cluster 支持跨节点事务:Redis Cluster 的
MULTI/EXEC要求所有 key 在同一 slot,跨 slot 会报错。 - 不要混淆 Kafka 的 offset 管理:自动提交(
enable.auto.commit=true)简单但可能丢消息;手动提交更可靠但代码复杂。 - 不要忽视 Kafka 的
max.poll.interval.ms:业务处理时间超过这个值,consumer 会被踢出 group 触发 rebalance。 - 不要给 Redis 设置过长 TTL:Redis 的过期删除是惰性 + 定期,超长 TTL 的 key 如果不再被访问,会长期占内存。
5. 常见追问应对
Q1: Redis 的 ZSet 是怎么实现的?为什么用跳表不用红黑树?
Model Answer:
Redis ZSet 的底层是 skiplist + hashtable 的组合:
- skiplist:按 score 排序,支持 O(logN) 的范围查询(
ZRANGEBYSCORE)- hashtable:
key -> score的映射,支持 O(1) 的ZSCORE为什么用跳表不用红黑树/AVL 树?
- 范围查询更简单:跳表按 score 排序后,找到起点后顺序遍历即可。红黑树的中序遍历需要递归或栈,代码复杂。
- 实现简单:跳表的插入/删除代码只有几十行,红黑树几百行,bug 更少。
- 常数更小:跳表平均层数 ~logN,但实际比较次数比红黑树少(缓存友好,跳跃访问)。
- 并发友好:跳表的节点插入是局部修改,锁粒度更小(虽然 Redis 单线程不需要,但设计思想如此)。
- 红黑树的优势是精确查询,但 ZSet 更需要范围查询,跳表更合适。
小数据时的优化:当元素数 < 128 且每个元素长度 < 64 字节时,用 ziplist 存储(紧凑数组),节省内存。
Q2: 如果 Kafka 的一个 partition 的数据量太大,怎么水平扩展?
Model Answer:
Kafka 的 partition 是不可拆分的,一个 partition 只能在一个 broker 上。
如果单个 partition 数据量太大:
- 增加 partition 数:新建 topic 时设更多 partition,老 topic 用
kafka-topics.sh --alter --partitions N增加。注意:已有 partition 的数据不会重分布,新数据会进入新 partition。- 按 key 分区改为轮询:如果按 key hash 分区导致某些 key 数据倾斜,改用轮询(
RoundRobinPartitioner)或自定义分区器。- 分层存储(Tiered Storage):Kafka 3.0+ 支持,老数据自动转到 S3,本地只保留热数据。
- 按时间切分 topic:如
risk-events-2024-01、risk-events-2024-02,按月切分。- Consumer 水平扩展:增加 consumer 数(不超过 partition 数),提高消费并行度。
大型加密货币交易所 场景:
- 交易事件按
symbol(交易对)分区,如果 BTCUSDT 交易量远大于其他,会导致分区倾斜。解决:
- 热点 symbol 拆成多个 sub-symbol(如
BTCUSDT-0、BTCUSDT-1)- 或自定义分区器,对热点 key 做二次 hash
Q3: Redis 的 Pipeline 和事务(MULTI/EXEC)有什么区别?
Model Answer:
维度 Pipeline 事务(MULTI/EXEC) 原理 客户端缓冲多条命令一次性发送到服务端 服务端将命令放入队列,EXEC 时原子执行 原子性 ❌ 不保证 ✅ 保证(不被其他命令穿插) 隔离性 ❌ 其他客户端命令可能穿插 ✅ EXEC 前其他命令不会执行 错误处理 逐条返回结果,不中断 语法错误时整个事务取消;运行时错误不取消 回滚 ❌ 无 ❌ Redis 事务不支持回滚(设计者认为 bug 比网络故障更容易导致错误,应该让 bug 暴露) 性能 高,减少 RTT 中,有队列开销 Pipeline 适用:批量读写,如一次写入 1000 个 key,减少网络往返。 事务适用:需要保证一组命令不被穿插,如
WATCH key+MULTI+INCR+EXEC实现乐观锁。Lua 脚本:如果需要原子性 + 逻辑判断,用
EVAL执行 Lua 脚本(Redis 单线程保证脚本原子执行)。
Q4: Kafka Producer 的 batch.size 和 linger.ms 怎么调优?
Model Answer:
batch.size:一个 batch 的最大字节数(默认 16KB)。batch 满后立即发送。linger.ms:发送前等待的时间(默认 0),等更多消息进入 batch,增加吞吐量但增加延迟。调优策略:
场景 batch.size linger.ms 说明 高吞吐、延迟不敏感(如日志) 32-128KB 10-100ms 攒更多消息再发 低延迟、高实时(如风控告警) 16KB 0-5ms 尽快发送 消息体大(如 JSON) 64-256KB 50ms 大消息需要更大 batch 消息体小(如 metrics) 16-32KB 100ms 小消息可以攒更多 其他参数:
compression.type=lz4/zstd:压缩减少网络带宽,CPU 开销小buffer.memory=32MB:Producer 发送缓冲,太小会阻塞max.in.flight.requests.per.connection=5:允许 5 个未确认请求,提高吞吐但可能乱序
Q5: Redis 主从复制的原理?全量同步和增量同步?
Model Answer:
主从复制流程:
- Slave 向 Master 发送
PSYNC ? -1(首次)或PSYNC runId offset(断线重连)- 如果是首次或 runId 不匹配,Master 执行 BGSAVE 生成 RDB,发送给 Slave
- Slave 清空数据,加载 RDB
- Master 将 复制缓冲区(replication backlog) 中 offset 之后的数据发送给 Slave
- 后续 Master 的写命令实时发送给 Slave
全量同步(Full Resynchronization):
- 触发:首次连接、Master 重启(runId 变化)、offset 不在 backlog 中
- Master fork 子进程生成 RDB,期间写命令进入缓冲区
- 缺点:大内存下 fork 耗时秒级,阻塞主线程
增量同步(Partial Resynchronization):
- 触发:网络闪断后重连,且 Slave 的 offset 仍在 Master 的 backlog 中
- Master 直接发送 backlog 中缺失的命令,无需 RDB
- 优点:秒级恢复,无阻塞
复制缓冲区(Backlog):
- 固定大小环形缓冲区(默认 1MB,可配)
- 记录最近传播的写命令
- Slave 重连时,如果 offset 差值 < backlog 大小,增量同步;否则全量同步
Redis 7.0 的 Share Replication Buffer:多 Slave 共享复制缓冲区,减少内存占用。
Q6: Kafka 的 Controller 是做什么的?如果 Controller 挂了怎么办?
Model Answer:
Controller 职责:
- 分区 Leader 选举:Broker 宕机时,Controller 从 ISR 中选新 Leader
- 分区重分配:Reassign Partition 时协调数据迁移
- Broker 注册管理:监听 ZooKeeper(或 KRaft)的 broker 上下线
- 元数据广播:将 Leader/ISR 变化广播给所有 broker
Controller 选举:
- ZooKeeper 模式:所有 broker 竞争 ZooKeeper 的
/controller临时节点,创建成功者成为 Controller- KRaft 模式:Quorum 投票选举(Raft 算法)
Controller 挂了:
- ZooKeeper 的
/controller临时节点自动删除,其他 broker 收到通知,重新选举- 选举期间,分区如果有 Leader 宕机,会暂时无法选举新 Leader(影响可用性)
- 通常 Controller 切换在 3 秒内完成
优化:
- Kafka 2.2+ 的 Sticky Controller:尽量让同一 broker 连任 Controller,减少元数据重新加载
- KRaft 模式下,Controller 是独立的节点(或 co-located),不处理客户端请求
Last Updated: 2026-05-14 Target Position: 大型加密货币交易所 Senior Backend Developer - Risk Study Tip: Redis 重点背 持久化对比、缓存三件套、分布式锁、一致性方案;Kafka 重点背 ISR/HW/LEO、零拷贝、Exactly-Once、Rebalance 优化。面试时主动提及 KRaft、Tiered Storage、@Contended 等关键词加分。