面试速查:Redis 与 Kafka 中间件

通识对照:Kafka 架构通识:分区日志、副本 ISR 与消费者组

面试速查:Redis 与 Kafka 中间件

Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。


面向岗位:大型加密货币交易所 Senior Backend Developer - Risk 考察目标:Redis 和 Kafka 是 Senior Backend 面试中占比最高的中间件,通常占 25%-35%。本文档覆盖核心原理、手写代码、线上排障、以及 Risk/Fraud 场景落地。


目录

  1. 核心速查表
  2. 手写代码精讲
  3. 高频面试题库
  4. 面试现场建议
  5. 常见追问应对

1. 核心速查表

1.1 Redis 核心速查

数据结构时间复杂度

数据结构典型命令时间复杂度底层实现
StringGET/SET/INCRO(1)SDS (Simple Dynamic String)
HashHGET/HSETO(1)ziplist (小) / hashtable (大)
ListLPUSH/RPOP/LRANGEO(1)/O(1)/O(N)quicklist (ziplist 链表)
SetSADD/SISMEMBERO(1)intset (小) / hashtable (大)
ZSetZADD/ZRANGE/ZRANGEBYSCOREO(logN)ziplist (小) / skiplist + hashtable (大)
BitmapSETBIT/GETBIT/BITCOUNTO(1)/O(1)/O(N)底层是 String (SDS)
HyperLogLogPFADD/PFCOUNTO(1)稀疏/密集编码,12KB 固定空间
GeoGEOADD/GEORADIUSO(logN)/O(N)底层 ZSet,score = geohash
StreamXADD/XREAD/XGROUPO(1)Rax 树 + listpack

持久化:RDB vs AOF

维度RDBAOF
原理快照,定时 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 协议交换状态。

缓存问题三件套

问题现象解决方案
缓存穿透查询不存在的数据,直接打到 DB1. 布隆过滤器预拦截;2. 缓存空值(null 或特殊标记),设短 TTL
缓存击穿热点 key 过期瞬间,大量请求打到 DB1. 互斥锁:只有一个线程去加载 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 单线程模型为什么还这么快?

  1. 纯内存操作:所有数据在内存,无磁盘 I/O
  2. 单线程避免上下文切换:没有多线程的竞争、锁、上下文切换开销
  3. 高效数据结构:SDS、ziplist、skiplist、intset 都经过精心优化
  4. I/O 多路复用:基于 epoll(Linux)/ kqueue(macOS),单线程处理数万连接
  5. 避免系统调用: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
PartitionTopic 的物理分片,每个 partition 是一个有序、不可变的日志
Offset消息在 partition 内的唯一标识(递增 long)
Replica分区副本,Leader 处理读写,Follower 同步
ISRIn-Sync Replicas:与 Leader 数据同步的副本集合
ARAssigned 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

触发条件:

  1. Consumer Group 内成员变化(新 consumer 加入 / 离开 / 崩溃)
  2. Topic 的 partition 数变化
  3. 消费者主动调用 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 代价最小
CooperativeStickySticky 的增量版本Kafka 2.4+ 推荐

2. 手写代码精讲

2.1 手写 Redis 分布式锁

题目

实现一个基于 Redis 的分布式锁,支持 lock()、unlock(),处理原子性、锁续期、可重入。

核心思路

  1. 加锁原子性:SET key value NX EX 30(Redis 2.6.12+ 的 SET 扩展),一条命令完成 set + nx + expire
  2. 防误删:value = 随机 token(如 UUID),解锁时用 Lua 脚本检查 token 是否匹配再删除
  3. 锁续期(Watch Dog):加锁后启动守护线程,每 10 秒检查锁是否还在,如果在则续期(类似 Redisson 的看门狗)
  4. 可重入: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时间说明
tryLockO(1)单次 Redis SET NX EX
unlockO(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)**时的位移安全。

核心思路

  1. Offset 存储:Kafka 内部 topic __consumer_offsets(Kafka 0.9+ 默认),或外部存储(如 Redis / MySQL)
  2. 自动提交:enable.auto.commit=true,poll 后按 auto.commit.interval.ms 定时提交。简单但可能丢消息(已消费未提交时崩溃)。
  3. 手动同步提交:consumer.commitSync(),消费完一批后同步提交,失败可重试。
  4. 手动异步提交:consumer.commitAsync(callback),不阻塞消费,但可能提交乱序。
  5. 再均衡时保存 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时间说明
pollO(1)从本地 buffer 取数据
commitSyncO(N)N = 提交的 partition 数,网络 RTT
seekO(1)修改本地 offset 指针

易错点

  • commitSync 的 offset 是"下一条":record.offset() + 1,不是当前消息的 offset。Kafka 记录的是下一次应该从哪消费。
  • Rebalance 前必须 commitSync:onPartitionsRevoked 里用异步提交可能导致提交失败未被感知,rebalance 后重复消费。
  • 不要在 onPartitionsAssigned 里做重初始化:如果耗时操作放在这里,会阻塞 rebalance 协议,导致 coordinator 认为 consumer 死亡,触发新一轮 rebalance。

大型加密货币交易所 / Risk 实际应用

  • 实时风控事件消费:risk-events topic 的 consumer group,手动提交保证每条事件处理完再 commit,失败时从外部存储的 checkpoint 恢复。
  • 交易对账消息:消费交易流水,处理完写 MySQL 后再 commit,保证"至少一次"且通过幂等保证"实际一次"。
  • 制裁名单变更通知:Kafka 通知各节点刷新缓存,手动提交 + 外部存储 offset,确保不遗漏通知。

2.3 手写消息幂等处理器

题目

实现一个消息消费的幂等处理器,基于 Redis + MySQL 双写,处理 Kafka 消息的**至少一次(At-Least-Once)**语义下的重复消费。

核心思路

  1. 唯一键:每条消息生成唯一 ID(topic + partition + offset 或业务唯一键如 orderId)
  2. Redis 去重:SETNX msg_id 1 EX 86400,设置成功说明是首次消费,继续处理;失败说明已消费,直接丢弃
  3. MySQL 去重:业务表加唯一索引(UNIQUE KEY uk_msg_id (msg_id)),插入时捕获 DuplicateKeyException
  4. Redis 为主,MySQL 为兜底:Redis 性能高但可能丢数据(持久化异常时),MySQL 唯一索引是最终一致性保障
  5. 双写原子性:先写 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 SETNXO(1)网络 RTT
DB INSERTO(1)唯一索引查询
总耗时~2 RTTRedis + 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+ 支持多线程。

高并发原因:

  1. 纯内存操作:无磁盘 I/O,内存访问 ns 级
  2. 高效数据结构:SDS、ziplist、skiplist、dict 都经过优化
  3. I/O 多路复用:单线程通过 epoll 管理数万连接,没有线程切换开销
  4. 避免锁竞争:单线程天然无锁,没有上下文切换和 cache line 竞争

瓶颈:

  1. 大 key 操作:HGETALL 一个百万 field 的 hash,LRANGE 百万元素的 list,会阻塞整个实例
  2. 复杂命令:KEYS *、SORT、SUNION 等 O(N) 命令
  3. 持久化 fork:BGSAVE / AOF rewrite 时 fork 子进程,大内存下 fork 耗时可达秒级,阻塞主线程
  4. 内存上限:单实例内存不宜超过 20-30GB(fork 时间、故障恢复时间)
  5. 网络带宽:零拷贝也受限于网卡带宽

易错点:

  • 不要说 "Redis 多线程所以高并发",核心原因是单线程 + 内存 + I/O 多路复用。
  • 也不要说 "Redis 完全单线程",6.0+ 的 I/O 是多线程的。

Q2: Redis 的大 Key 和热 Key 怎么发现和解决?

标准答案:

发现大 Key:

  1. redis-cli --bigkeys:扫描全库,统计每种类型最大的 key
  2. MEMORY USAGE key:精确查看单个 key 的内存占用
  3. RDB Tools(rdbtools / redis-rdb-tools):分析 RDB 文件,离线统计大 key
  4. 监控 INFO COMMANDSTATS:找出执行慢命令的 key

解决大 Key:

  1. 拆分:大 hash 拆成多个小 hash(如 user:1000 拆成 user:1000:profile、user:1000:settings)
  2. 压缩:value 用 protobuf / msgpack 替代 JSON
  3. 异步删除:Redis 4.0+ 用 UNLINK 替代 DEL,后台线程释放内存

发现热 Key:

  1. MONITOR 命令实时抓流量(生产环境慎用,性能影响大)
  2. redis-cli --hotkeys(需要配置 maxmemory-policy 为 LFU)
  3. 业务层埋点统计 key 访问频率
  4. 代理层(如 Twemproxy / Codis)统计

解决热 Key:

  1. 本地缓存:本地 Caffeine / Guava Cache 做 L1,Redis 做 L2
  2. key 拆分:热 key 加随机后缀(如 config:v1、config:v2),分散到多个 key
  3. 读写分离:从节点分担读压力
  4. Proxy 层限流:对单个 key 的 QPS 限流

易错点:

  • redis-cli --bigkeys 是扫描全库,大 key 多的情况下会阻塞生产实例。建议在 slave 上执行或低峰期执行。
  • 本地缓存解决热 key 时,要注意数据一致性和缓存失效广播。

Q3: Redis Cluster 模式下,一个请求是怎么路由到正确节点的?

标准答案:

  1. 计算 slot:slot = CRC16(key) % 16384
  2. 查找节点:客户端维护 slot -> node 的映射表(cluster slots 命令获取)
  3. 发送请求:直接发送到目标节点
  4. MOVED 重定向:如果 key 已迁移(resharding),目标节点返回 MOVED slot new_node_ip:port,客户端更新映射表并重试
  5. 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 自动处理)
  • 事务(MULTI)跨 slot:WATCH/MULTI/EXEC 的所有 key 必须在同一个 slot。

Q4: 缓存和数据库一致性问题怎么解决?

标准答案:

方案对比:

方案实现优点缺点
Cache Aside读:先读缓存,miss 读 DB 写缓存;写:先写 DB,再删缓存简单,最常用极端情况下短暂不一致
Read/Write Through读写都走缓存,缓存负责同步 DB对应用透明缓存组件复杂(如 Redis 做不到)
Write Behind先写缓存,异步写 DB写性能极高数据丢失风险大

Cache Aside 详解(最常用):

  1. 读:先读 Redis,命中直接返回;miss 读 MySQL,写回 Redis
  2. 写:先更新 MySQL,再删除 Redis(不是更新!)
    • 为什么删不是更新?因为并发写时,两个线程写 DB 的顺序和写缓存的顺序可能颠倒,导致缓存脏数据更久
    • 删除后下次读会自动从 DB 加载最新值

双写不一致的极端情况:

  • 线程 A 读缓存 miss,读 DB 得到旧值 v1
  • 线程 B 写 DB 为 v2,删缓存
  • 线程 A 把 v1 写回缓存
  • 结果:缓存是 v1(旧),DB 是 v2(新)

解决方案:

  1. 延时双删:写操作先删缓存 -> 写 DB -> 睡眠 200ms -> 再删缓存。降低不一致窗口
  2. 消息队列异步删:写 DB 后发 MQ,消费者异步删缓存。保证最终一致性
  3. ** canal + MQ**:监听 MySQL binlog,异步删缓存。对业务零侵入
  4. 设置短 TTL:让不一致数据自然过期

易错点:

  • 不要先删缓存再写 DB。如果删完缓存后、写 DB 前,另一个线程读 miss 加载了旧值到缓存,就会不一致。
  • 正确的顺序是:先写 DB,再删缓存。
  • 延时双删的"睡眠"时间要大于一次读操作的耗时(通常 100-500ms)。

Q5: Redis 的过期删除策略是什么?

标准答案:

Redis 同时用两种策略:

  1. 惰性删除(Lazy Expiration):
    • 访问 key 时检查是否过期,过期则删除
    • 优点:不消耗 CPU
    • 缺点:过期 key 如果不被访问,一直占内存
  2. 定期删除(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 宕机时的选举:

  1. Controller 从 ISR 中选新 Leader(第一个)
  2. 如果 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 为什么性能这么高?零拷贝具体是怎么做的?

标准答案:

高性能四大支柱:

  1. 顺序写盘:传统数据库随机写慢,Kafka 追加写 log 文件,磁盘顺序写速度 ≈ 内存随机写
  2. Page Cache:OS 的 page cache 缓存磁盘数据,consumer 读消息时先读 page cache,命中则零磁盘 I/O
  3. 零拷贝(Zero-Copy):
    • 传统方式:磁盘 -> 内核 buffer -> 用户 buffer -> Socket buffer -> 网卡(4 次拷贝,4 次上下文切换)
    • Kafka 方式:磁盘 -> Page Cache -> sendfile() DMA 到网卡(2 次拷贝,2 次上下文切换)
    • 如果 consumer 和 broker 在同一机器,直接从 page cache 读,0 次磁盘 I/O
  4. 批量与压缩: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。触发条件:

  1. Group 内成员变化(加入/离开/崩溃)
  2. Topic 的 partition 数变化
  3. Consumer 调用 subscribe() / unsubscribe()

Rebalance 的问题:

  • 消费暂停:rebalance 期间整个 group 停止消费
  • 重复消费:rebalance 前未提交的 offset,新 consumer 从旧 offset 开始消费
  • 消费延迟:频繁 rebalance 导致消息积压

优化方案:

  1. 减少 Consumer 数量波动:
    • 设置合理的 session.timeout.ms(默认 10s)和 heartbeat.interval.ms(默认 3s)
    • max.poll.interval.ms 要大于业务处理时间,避免处理慢被踢出 group
  2. 使用 Cooperative Rebalance(Kafka 2.4+):
    • 配置 partition.assignment.strategy=org.apache.kafka.clients.consumer.CooperativeStickyAssignor
    • 增量 rebalance,只迁移需要调整的 partition
  3. Consumer Rebalance Listener:
    • onPartitionsRevoked() 里同步提交 offset
    • onPartitionsAssigned() 里恢复处理状态
  4. 增加 partition 数:减少单个 consumer 负责的 partition 数,rebalance 时变动更小
  5. 避免频繁加入/退出:不要每次 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 端:

  1. 幂等性 Producer:enable.idempotence=true,Broker 去重
    • 每条消息带 PID(Producer ID)+ Sequence Number
    • Broker 按 (PID, Partition, SeqNum) 去重
    • 局限:只保证单分区内不重复,跨 session 不保证(重启后 PID 会变)
  2. 事务 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 怎么选?

标准答案:

维度KafkaRabbitMQRocketMQ
定位高吞吐日志/事件流通用消息队列金融级可靠消息
吞吐最高(百万级/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 树?

  1. 范围查询更简单:跳表按 score 排序后,找到起点后顺序遍历即可。红黑树的中序遍历需要递归或栈,代码复杂。
  2. 实现简单:跳表的插入/删除代码只有几十行,红黑树几百行,bug 更少。
  3. 常数更小:跳表平均层数 ~logN,但实际比较次数比红黑树少(缓存友好,跳跃访问)。
  4. 并发友好:跳表的节点插入是局部修改,锁粒度更小(虽然 Redis 单线程不需要,但设计思想如此)。
  5. 红黑树的优势是精确查询,但 ZSet 更需要范围查询,跳表更合适。

小数据时的优化:当元素数 < 128 且每个元素长度 < 64 字节时,用 ziplist 存储(紧凑数组),节省内存。


Q2: 如果 Kafka 的一个 partition 的数据量太大,怎么水平扩展?

Model Answer:

Kafka 的 partition 是不可拆分的,一个 partition 只能在一个 broker 上。

如果单个 partition 数据量太大:

  1. 增加 partition 数:新建 topic 时设更多 partition,老 topic 用 kafka-topics.sh --alter --partitions N 增加。注意:已有 partition 的数据不会重分布,新数据会进入新 partition。
  2. 按 key 分区改为轮询:如果按 key hash 分区导致某些 key 数据倾斜,改用轮询(RoundRobinPartitioner)或自定义分区器。
  3. 分层存储(Tiered Storage):Kafka 3.0+ 支持,老数据自动转到 S3,本地只保留热数据。
  4. 按时间切分 topic:如 risk-events-2024-01、risk-events-2024-02,按月切分。
  5. 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.sizelinger.ms说明
高吞吐、延迟不敏感(如日志)32-128KB10-100ms攒更多消息再发
低延迟、高实时(如风控告警)16KB0-5ms尽快发送
消息体大(如 JSON)64-256KB50ms大消息需要更大 batch
消息体小(如 metrics)16-32KB100ms小消息可以攒更多

其他参数:

  • compression.type=lz4/zstd:压缩减少网络带宽,CPU 开销小
  • buffer.memory=32MB:Producer 发送缓冲,太小会阻塞
  • max.in.flight.requests.per.connection=5:允许 5 个未确认请求,提高吞吐但可能乱序

Q5: Redis 主从复制的原理?全量同步和增量同步?

Model Answer:

主从复制流程:

  1. Slave 向 Master 发送 PSYNC ? -1(首次)或 PSYNC runId offset(断线重连)
  2. 如果是首次或 runId 不匹配,Master 执行 BGSAVE 生成 RDB,发送给 Slave
  3. Slave 清空数据,加载 RDB
  4. Master 将 复制缓冲区(replication backlog) 中 offset 之后的数据发送给 Slave
  5. 后续 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 职责:

  1. 分区 Leader 选举:Broker 宕机时,Controller 从 ISR 中选新 Leader
  2. 分区重分配:Reassign Partition 时协调数据迁移
  3. Broker 注册管理:监听 ZooKeeper(或 KRaft)的 broker 上下线
  4. 元数据广播:将 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 等关键词加分。