ZooKeeper 面试题

Client → Follower → Leader
  Leader 分配全局单调递增 zxid（64 位：高 32 位 epoch，低 32 位 counter）
  Leader 为 Follower 发送 PROPOSAL（含 zxid + 数据）
  Follower 写入本地日志后回复 ACK
  Leader 收到 ≥ 半数 Follower 的 ACK 后发送 COMMIT
  Follower 提交事务并响应 Client

# 查看当前节点状态
echo srvr | nc 127.0.0.1 2181
# 输出关键字段：Mode (leader/follower/standalone), Zxid

# 5 节点集群 zoo.cfg
tickTime=2000
initLimit=10      # 初始化连接超时（tickTime 倍数）
syncLimit=5       # Follower 与 Leader 同步超时
dataDir=/data/zk
dataLogDir=/data/zk/log
clientPort=2181
server.1=zk1:2888:3888   # myid=1, 内部通信 2888, 选举 3888
server.2=zk2:2888:3888
server.3=zk3:2888:3888
server.4=zk4:2888:3888
server.5=zk5:2888:3888

/
├── /services          # 服务注册根
│   ├── /order-service
│   │   ├── /instance-0001   # 临时顺序节点
│   │   ├── /instance-0002
│   │   └── /instance-0003
│   └── /pay-service
├── /config            # 配置中心
│   ├── /db.properties
│   └── /app.yaml
├── /locks             # 分布式锁
│   ├── /order-lock
│   └── /pay-lock
└── /election          # Master 选举
    └── /leader

# getData 注册数据变更 Watcher
getData /services/order, true

# getChildren 注册子节点变更 Watcher
ls /services/order true

# exists 注册存在性变更 Watcher（用于不存在节点）
stat /lock/order true

// 一次性 Watcher
Stat stat = zk.exists("/config/db", watchedEvent -> {
    if (watchedEvent.getType() == Watcher.Event.EventType.NodeDataChanged) {
        // 重新获取数据
        byte[] newData = zk.getData("/config/db", false, null);
        reloadConfig(newData);
        // 关键：重新注册 Watcher（一次性失效）
        reRegisterWatcher();
    }
});

// 持久 Watcher（推荐 Curator）
NodeCache nodeCache = new NodeCache(client, "/config/db");
nodeCache.start(true);
nodeCache.getListenable().addListener(() -> {
    ChildData data = nodeCache.getCurrentData();
    reloadConfig(data.getData());
});

# 服务实例启动时注册临时节点
create -e -s /services/order-svc/instance- "${INSTANCE_INFO}"

# 客户端通过 getChildren 发现所有实例
ls /services/order-svc

# 实例宕机 → session 超时 → 临时节点自动删除
# 客户端收到 NodeChildrenChanged 事件后刷新服务列表

// 步骤 1：所有客户端在 /lock/order 下创建临时顺序节点
String myPath = zk.create("/lock/order/guid-", null,
    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
// myPath = /lock/order/guid-0000000001

// 步骤 2：获取所有子节点，排序最小的获取锁
List<String> children = zk.getChildren("/lock/order", false);
Collections.sort(children);
if (myPath.equals("/lock/order/" + children.get(0))) {
    // 获得锁
} else {
    // 监听前一个节点的删除事件
    String prevNode = children.get(indexOf(myPath) - 1);
    zk.exists("/lock/order/" + prevNode, watcher);
}

// 步骤 3：释放锁（删除节点或断开连接）
zk.delete(myPath, -1);

// 多个客户端同时创建临时顺序节点，最小者当选 Master
String myPath = zk.create("/election/leader-", null,
    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
List<String> children = zk.getChildren("/election", false);
if (myPath.endsWith(children.get(0))) {
    becomeMaster();
} else {
    // 监听最小节点删除事件，等待晋升
}

// 生产者
zk.create("/queue/task-", data, ..., CreateMode.PERSISTENT_SEQUENTIAL);

// 消费者
List<String> tasks = zk.getChildren("/queue", false);
Collections.sort(tasks);
// 处理 /queue/task-0000000001

# 写入配置（持久节点）
create /config/app.properties "host=db.example.com\nport=3306"
set /config/app.properties "host=newdb.example.com\nport=3306"

# 客户端 Watcher 监听配置变更
stat /config/app.properties true

/services
  /order-service
    /instance-0001 (临时节点, host:port, 负载权重)
    /instance-0002
  /pay-service
    /instance-0001

// Curator LeaderLatch 实现
LeaderLatch leaderLatch = new LeaderLatch(client, "/election/master");
leaderLatch.start();
if (leaderLatch.hasLeadership()) {
    // 执行业务逻辑（如 HDFS NameNode、YARN ResourceManager）
} else {
    leaderLatch.getLeader().getId(); // 获取当前 Master ID
}

echo mntr | nc 127.0.0.1 2181

# zk 配置文件启用 JMX
JMXHOST=""
JMXPORT="9999"

# 启动 JMX Exporter
java -javaagent:/opt/jmx_prometheus_javaagent.jar=12345:/opt/jmx-exporter-config.yml \
  -jar zookeeper.jar start

# 检查各节点状态是否一致
for i in 1 2 3 4 5; do
  echo "=== zk$i ==="
  echo srvr | nc zk$i 2181 | grep -E "Mode|Zxid"
done

# 期望输出：Mode 一致，Zxid 接近
# zk1: Mode: leader   Zxid: 0x200000123
# zk2: Mode: follower Zxid: 0x200000123
# zk3: Mode: follower Zxid: 0x200000123

完整命名空间：
/
├── /app-a
│   ├── /config
│   └── /locks
├── /app-b
│   ├── /config
│   └── /services
└── /shared
    └── /discovery

App-A 客户端连接后 chroot=/app-a：
  /config → 实际访问 /app-a/config
  /locks → 实际访问 /app-a/locks

# 连接字符串中追加 chroot 路径
zkCli.sh -server zk1:2181,zk2:2181,zk3:2181/app-a

# 编程方式
String connectString = "zk1:2181,zk2:2181,zk3:2181/app-a";
ZooKeeper zk = new ZooKeeper(connectString, 30000, watcher);

# 创建节点时指定 ACL
create /config/db "jdbc:mysql://..." digest:user:passwd:cdrwa

# ACL 模式：
# - world:anyone（默认）
# - auth:user
# - digest:user:BASE64(SHA1(password))  生产推荐
# - ip:192.168.1.0/24
# - x509:subject
# - sasl:user

# 权限位：cdrwa = create/delete/read/write/admin

# 步骤 1：检查 ZK 各节点状态
echo mntr | nc zk1 2181 | grep -E "avg_latency|outstanding_requests|followers"
# 发现 zk1 的 avg_latency 持续 > 200ms，outstanding_requests > 500

# 步骤 2：检查 GC 日志
jstat -gcutil <pid> 1000
# 发现 Full GC 频率 30s 一次，单次 1-2s

# 步骤 3：检查堆内存配置
echo envi | nc zk1 2181 | grep -i heap
# 发现仅 2GB 堆，业务量增长后不足

# 1. 堆内存扩容
export KAFKA_HEAP_OPTS="-Xms8g -Xmx8g"  # 推荐 8-16G

# 2. 启用 G1GC（4.0+ 默认）
export KAFKA_JVM_PERFORMANCE_OPTS="-XX:+UseG1GC -XX:MaxGCPauseMillis=200"

# 3. 调大 tickTime 和 initLimit
tickTime=4000         # 4s（默认 2s），降低对网络抖动敏感度
initLimit=30          # 120s 初始化超时
syncLimit=10          # 40s 同步超时

# 4. 独立磁盘用于事务日志
dataLogDir=/data/fast-ssd/zk-log  # 独立 SSD，避免与 snapshot 同盘 IO 竞争

// 反例：每个服务实例创建大量子节点
create /services/order-svc/instance-001/health
create /services/order-svc/instance-001/metrics
create /services/order-svc/instance-001/config
// 单实例 100+ 节点，500 实例 = 5 万+ 节点

// 正例 1：单实例多数据合并到一个 Znode
create -e /services/order-svc/instance-001 "{\"health\":\"ok\",\"qps\":100,...}"

// 正例 2：使用有序节点 + JSON 数据，限制子节点数
// 推荐：实例元数据写入 Znode data，目录只用临时节点标识存在性

# 步骤 1：确认是否真的发生脑裂（极少见，但需验证）
for node in zk1 zk2 zk3 zk4 zk5; do
  echo "=== $node ==="
  echo srvr | nc $node 2181 | grep -E "Mode|Zxid"
done

# 步骤 2：如果发现多个 Leader，强制重启旧 Leader
ssh zk1 "kill -9 $(pgrep -f QuorumPeerMain)"

# 步骤 3：清理旧 Leader 的临时数据
rm -rf /data/zk/version-2/*

# 步骤 4：旧节点以全新状态加入新集群
/data/zookeeper/bin/zkServer.sh start

// 反例：每次连接都注册
zk.exists("/config", new Watcher() {
    @Override
    public void process(WatchedEvent event) {
        // 重新加载配置但未重新注册
    }
});

// 正例：使用 Curator 的 NodeCache（自动管理 Watcher）
NodeCache nodeCache = new NodeCache(client, "/config");
nodeCache.start(true);
nodeCache.getListenable().addListener(() -> reload());

// 资源清理
Runtime.getRuntime().addShutdownHook(() -> {
    CloseableUtils.closeQuietly(nodeCache);
    CloseableUtils.closeQuietly(client);
});

# 监控 Watch 数量
echo wchp | nc zk1 2181 | head -20
# 单路径 Watch > 1000 需告警