知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 06 - ZooKeeper 与协调服务 ## ZooKeeper 简介 ZooKeeper 是 Apache 开源的分布式协调服务,提供高可用的分布式数据管理与协调框架。 ### 核心功能  *图:ZooKeeper 的六项核心功能* ``` ┌─────────────────────────────────────────────────────────────┐ │ ZooKeeper 核心功能 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ 配置管理 │ │ 命名服务 │ │ 分布式锁 │ │ │ │ │ │ │ │ │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ 集群管理 │ │ Leader选举 │ │ 屏障/队列 │ │ │ │ │ │ │ │ │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘ ``` ### ZooKeeper 架构  *图:ZooKeeper 集群:Leader 与 Follower 经 ZAB 同步* ``` ┌─────────────────────────────────────┐ │ Client Applications │ └──────────────────┬──────────────────┘ │ ┌────────────────────────┼────────────────────────┐ │ │ │ ▼ ▼ ▼ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ Server1 │◄───────────►│ Server2 │◄───────────►│ Server3 │ │ (Leader)│ │(Follower)│ │(Follower)│ └─────────┘ └─────────┘ └─────────┘ │ │ │ └────────────────────────┴────────────────────────┘ ZAB 协议同步 特点: - 奇数节点(2n+1)容忍 n 个故障 - Leader 处理写请求 - 所有节点都可处理读请求 - ZAB(ZooKeeper Atomic Broadcast)保证一致性 ``` ## 数据模型 ### ZNode 树结构  *图:ZNode 树状数据模型与单个节点内容* ``` ZooKeeper 数据组织为树状结构,类似文件系统 /(根节点) │ ┌────────────┼────────────┐ │ │ │ /app1 /app2 /config │ │ │ ┌───┴───┐ ┌───┴───┐ /db.properties /server1 /server2 /lock 每个节点(ZNode)包含: - 数据(最大 1MB) - 子节点 - 元数据(版本、ACL、时间戳等) ``` ### ZNode 类型 | 类型 | 说明 | 用途 | |------|------|------| | **持久节点** | 创建后一直存在,除非显式删除 | 配置管理 | | **临时节点** | 会话结束时自动删除 | 服务发现、分布式锁 | | **持久顺序节点** | 持久 + 自动追加递增序号 | 分布式队列 | | **临时顺序节点** | 临时 + 自动追加递增序号 | 分布式锁、Leader 选举 | ```java // 创建不同类型的节点 public class ZNodeExample { private ZooKeeper zk; public void createNodes() throws Exception { // 持久节点 zk.create("/config", "data".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); // 临时节点 zk.create("/services/instance1", "host:port".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL); // 持久顺序节点 zk.create("/queue/item-", "data".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL); // 实际创建:/queue/item-0000000001 // 临时顺序节点 zk.create("/locks/lock-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); // 实际创建:/locks/lock-0000000001 } } ``` ### Watcher 机制  *图:Watcher 注册与事件通知机制及事件类型* ``` Watcher 是 ZooKeeper 的核心机制,用于实现事件通知 ┌──────────┐ ┌──────────────┐ │ Client │ ── 1. 注册 Watcher ───→ │ ZooKeeper │ │ │ │ │ │ │ ←─ 2. 节点变化通知 ───── │ /node │ │ │ │ │ └──────────┘ └──────────────┘ Watcher 特点: 1. 一次性:触发后需要重新注册 2. 有序性:先注册先触发 3. 轻量级:只通知变化,不发送数据 事件类型: - NodeCreated:节点创建 - NodeDeleted:节点删除 - NodeDataChanged:数据变化 - NodeChildrenChanged:子节点变化 ```  ```java public class WatcherExample implements Watcher { private ZooKeeper zk; @Override public void process(WatchedEvent event) { String path = event.getPath(); EventType type = event.getType(); switch (type) { case NodeCreated: System.out.println("节点创建: " + path); break; case NodeDeleted: System.out.println("节点删除: " + path); break; case NodeDataChanged: System.out.println("数据变化: " + path); // 重新注册 Watcher try { zk.getData(path, this, null); } catch (Exception e) { e.printStackTrace(); } break; case NodeChildrenChanged: System.out.println("子节点变化: " + path); break; } } } ``` ## 分布式锁 ### 简单分布式锁  *图:临时节点实现分布式锁:抢锁成功与失败* ``` 利用 ZooKeeper 的临时节点实现 获取锁:创建临时节点 /locks/my-lock 释放锁:删除节点 或 会话超时自动删除 ┌───────────┐ ┌──────────────┐ │ Client A │ ── create ──────→ │ /locks/lock │ ✓ 成功获取锁 └───────────┘ └──────────────┘ ↑ ┌───────────┐ │ │ Client B │ ── create ──────────────→│ ✗ 节点已存在 └───────────┘ ``` ```java public class SimpleDistributedLock { private ZooKeeper zk; private String lockPath = "/locks/my-lock"; public boolean tryLock() { try { zk.create(lockPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL); return true; } catch (KeeperException.NodeExistsException e) { // 锁已被占用 return false; } } public void unlock() { try { zk.delete(lockPath, -1); } catch (Exception e) { // 处理异常 } } } ``` ### 公平分布式锁(推荐)  *图:临时顺序节点实现公平锁并避免惊群* ``` 利用临时顺序节点实现公平锁,避免惊群效应 获取锁流程: 1. 创建临时顺序节点 /locks/lock- 2. 获取所有子节点,检查自己是否是最小的 3. 如果是最小的,获取锁成功 4. 否则监听比自己小的前一个节点 公平锁排队机制: 初始状态:3 个客户端竞争锁 /locks/ ├── lock-0000000001 (Client A) ← 序号最小,持有锁! ├── lock-0000000002 (Client B) ← 监听 lock-001,等待 └── lock-0000000003 (Client C) ← 监听 lock-002,等待 Client A 释放锁(删除 lock-001): /locks/ ├── lock-0000000002 (Client B) ← 收到 NodeDeleted 通知,检查自己是否最小 → 是!获取锁 ✓ └── lock-0000000003 (Client C) ← 仍然监听 lock-002,等待 关键:每个 Client 只监听前一个节点 → Client B 释放时,只有 Client C 被通知 → 不会惊群(避免所有等待方同时苏醒抢锁) 对比非公平锁: ┌───────────────────────────────────────────────────────────┐ │ 非公平锁:所有等待方监听同一节点 │ │ 节点释放 → 所有等待方同时苏醒 → 惊群 → 只有 1 个成功 │ │ │ │ 公平锁:每个等待方监听自己的前一个节点 │ │ 节点释放 → 只有下一个节点苏醒 → 无惊群 → 按序获取 │ └───────────────────────────────────────────────────────────┘ ```  ```java public class FairDistributedLock { private ZooKeeper zk; private String lockPath = "/locks"; private String currentLock; private CountDownLatch latch; public void lock() throws Exception { // 1. 创建临时顺序节点 currentLock = zk.create(lockPath + "/lock-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); while (true) { // 2. 获取所有子节点 List<String> children = zk.getChildren(lockPath, false); Collections.sort(children); String currentNode = currentLock.substring(lockPath.length() + 1); int index = children.indexOf(currentNode); // 3. 如果是最小的节点,获取锁成功 if (index == 0) { return; } // 4. 监听前一个节点 String prevNode = children.get(index - 1); latch = new CountDownLatch(1); Stat stat = zk.exists(lockPath + "/" + prevNode, event -> { if (event.getType() == EventType.NodeDeleted) { latch.countDown(); } }); // 节点可能已经被删除 if (stat != null) { latch.await(); } } } public void unlock() throws Exception { zk.delete(currentLock, -1); } } ```  ## Leader 选举 ### 选举算法  *图:ZK Leader 选举五步流程与四项优势* ``` 利用临时顺序节点实现 Leader 选举 ZK Leader 选举完整流程: 初始状态:3 个 Server 竞争 Leader Step 1: 各自创建临时顺序节点 /election/ ├── node-0000000001 (Server A) ← 序号最小 ├── node-0000000002 (Server B) └── node-0000000003 (Server C) Step 2: 检查自己是否是最小的 → Server A 最小 → Server A 成为 Leader Server B 监听 node-001 Server C 监听 node-002 Step 3: Server A 宕机 → 会话超时 → node-001 自动删除 Step 4: Server B 收到 NodeDeleted(node-001) 通知 检查自己是否最小 → 是!→ Server B 成为新 Leader Server C 监听 node-002(不变,因为 node-002 现在是第一个) Step 5: Server A 重启 → 创建 node-0000000004 发现自己不是最小 → 监听 node-003(前一个),等待 核心优势: 1. 自动故障转移:Leader 宕机 → 下一台自动接替 2. 无单点:所有节点平等竞争 3. 会话机制保证:宕机后临时节点自动删除 4. 有序切换:按创建顺序依次接替 ```  ### Leader 选举流程 ```java public class LeaderElection { private ZooKeeper zk; private String electionPath = "/election"; private String currentNode; private LeaderChangeListener listener; public void participate() throws Exception { // 创建选举根节点 try { zk.create(electionPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } catch (KeeperException.NodeExistsException ignored) {} // 创建临时顺序节点 currentNode = zk.create(electionPath + "/node-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); checkLeadership(); } private void checkLeadership() throws Exception { List<String> children = zk.getChildren(electionPath, false); Collections.sort(children); String currentName = currentNode.substring(electionPath.length() + 1); int index = children.indexOf(currentName); if (index == 0) { // 我是 Leader listener.onBecomeLeader(); } else { // 监听前一个节点 String prevNode = children.get(index - 1); zk.exists(electionPath + "/" + prevNode, event -> { if (event.getType() == EventType.NodeDeleted) { try { checkLeadership(); } catch (Exception e) { e.printStackTrace(); } } }); } } } ``` ## 服务发现 ### 服务注册与发现  *图:临时节点实现服务注册与发现* ``` 服务注册: 服务启动时在 ZooKeeper 创建临时节点 服务发现: 消费者监听服务节点列表变化 /services └── /user-service ├── instance-001 (192.168.1.1:8080) 临时节点 ├── instance-002 (192.168.1.2:8080) 临时节点 └── instance-003 (192.168.1.3:8080) 临时节点 ``` ```java // 服务注册 public class ServiceRegistry { private ZooKeeper zk; public void register(String serviceName, String address) throws Exception { String servicePath = "/services/" + serviceName; // 创建服务根节点 try { zk.create("/services", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); zk.create(servicePath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT); } catch (KeeperException.NodeExistsException ignored) {} // 创建临时节点(服务实例) zk.create(servicePath + "/instance-", address.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL); } } // 服务发现 public class ServiceDiscovery { private ZooKeeper zk; private List<String> servers = new CopyOnWriteArrayList<>(); public void discover(String serviceName) throws Exception { String servicePath = "/services/" + serviceName; updateServerList(servicePath); // 监听子节点变化 zk.getChildren(servicePath, event -> { if (event.getType() == EventType.NodeChildrenChanged) { try { updateServerList(servicePath); } catch (Exception e) { e.printStackTrace(); } } }); } private void updateServerList(String path) throws Exception { List<String> children = zk.getChildren(path, true); List<String> newServers = new ArrayList<>(); for (String child : children) { byte[] data = zk.getData(path + "/" + child, false, null); newServers.add(new String(data)); } servers.clear(); servers.addAll(newServers); System.out.println("服务列表更新: " + servers); } public String getServer() { // 简单轮询 int index = ThreadLocalRandom.current().nextInt(servers.size()); return servers.get(index); } } ``` ## etcd 对比 ### ZooKeeper vs etcd | 对比项 | ZooKeeper | etcd | |--------|-----------|------| | 一致性协议 | ZAB | Raft | | 数据模型 | 树形结构 | 扁平 KV | | 语言 | Java | Go | | Watch | 一次性 | 持续 Watch | | 事务 | Multi 操作 | 事务支持 | | 认证 | ACL | RBAC + TLS | | 典型用户 | Kafka, Hadoop | Kubernetes | ### etcd 示例 ```java // 使用 jetcd 客户端 public class EtcdExample { private Client client; private KV kvClient; private Watch watchClient; public void init() { client = Client.builder() .endpoints("http://localhost:2379") .build(); kvClient = client.getKVClient(); watchClient = client.getWatchClient(); } // 写入 public void put(String key, String value) throws Exception { kvClient.put( ByteSequence.from(key, StandardCharsets.UTF_8), ByteSequence.from(value, StandardCharsets.UTF_8) ).get(); } // 读取 public String get(String key) throws Exception { GetResponse response = kvClient.get( ByteSequence.from(key, StandardCharsets.UTF_8) ).get(); if (response.getKvs().isEmpty()) { return null; } return response.getKvs().get(0).getValue() .toString(StandardCharsets.UTF_8); } // Watch(持续监听) public void watch(String key) { watchClient.watch( ByteSequence.from(key, StandardCharsets.UTF_8), watchResponse -> { for (WatchEvent event : watchResponse.getEvents()) { System.out.println("事件: " + event.getEventType()); System.out.println("Key: " + event.getKeyValue().getKey()); System.out.println("Value: " + event.getKeyValue().getValue()); } } ); } } ``` ## 最佳实践 ### 使用注意事项 ``` 1. 不要在 ZooKeeper 存储大量数据 - 每个节点限制 1MB - 设计为存储元数据,不是业务数据 2. 避免创建过深的节点层级 - 影响性能 - 增加维护难度 3. 合理使用 Watcher - Watcher 是一次性的,需要重新注册 - 处理好 Watcher 回调中的异常 4. 处理会话超时 - 实现重连逻辑 - 考虑临时节点自动删除的影响 5. 使用 Curator 简化开发 - 封装了重试、连接管理 - 提供分布式锁、Leader选举等高级 Recipe ``` ### 使用 Curator ```java // Curator 是更推荐的 ZooKeeper 客户端 public class CuratorExample { private CuratorFramework client; public void init() { client = CuratorFrameworkFactory.builder() .connectString("localhost:2181") .sessionTimeoutMs(5000) .retryPolicy(new ExponentialBackoffRetry(1000, 3)) .build(); client.start(); } // 分布式锁 public void lockExample() throws Exception { InterProcessMutex lock = new InterProcessMutex(client, "/locks/mylock"); if (lock.acquire(10, TimeUnit.SECONDS)) { try { // 临界区代码 } finally { lock.release(); } } } // Leader 选举 public void leaderExample() throws Exception { LeaderSelector selector = new LeaderSelector(client, "/election", new LeaderSelectorListenerAdapter() { @Override public void takeLeadership(CuratorFramework client) throws Exception { System.out.println("我成为 Leader 了!"); // 执行 Leader 工作 Thread.sleep(Long.MAX_VALUE); } }); selector.autoRequeue(); selector.start(); } } ``` ## 本章小结 - **ZooKeeper** 是分布式协调服务,基于 ZAB 协议保证一致性 - **数据模型**:树形结构,节点类型包括持久/临时、顺序/非顺序 - **Watcher**:一次性事件通知机制 - **分布式锁**:利用临时顺序节点实现公平锁 - **Leader 选举**:临时顺序节点 + 监听实现 - **服务发现**:临时节点注册,Watch 感知变化 - **etcd**:Kubernetes 生态的替代方案,基于 Raft ## 思考题 1. ZooKeeper 的会话(Session)有什么作用?会话超时会发生什么? 2. 分布式锁为什么推荐使用临时顺序节点而不是普通临时节点? 3. 如果 ZooKeeper 集群中 Leader 宕机,系统会如何处理? ## QA ### Q1:ZooKeeper 的会话(Session)有什么作用?会话超时会发生什么? Session 是客户端和 ZooKeeper 集群之间的生命周期上下文,用来维护身份、心跳、临时节点和 Watcher 绑定关系。只要客户端持续心跳,会话就有效;一旦超时,ZooKeeper 会认为客户端失联,自动删除该会话创建的临时节点,并触发相关 Watcher。对依赖临时节点实现服务注册、选主、分布式锁的场景来说,这正是故障自动清理的基础。 ### Q2:为什么分布式锁推荐使用临时顺序节点而不是普通临时节点? 因为普通临时节点只有“抢到或失败”两种结果,竞争激烈时会造成大量无序重试和惊群。临时顺序节点会为每个请求自动分配序号,所有客户端只需要关注自己前一个节点是否释放,谁序号最小谁拿锁。这样既能保证公平性,又能显著减少无效唤醒和竞争。 ### Q3:如果 ZooKeeper 集群中 Leader 宕机,系统会如何处理? 只要存活节点仍然达到多数派,集群就会进入新一轮选举,选出新的 Leader,并完成数据同步后继续提供服务。在选举期间,写请求会短暂不可用;选举完成后恢复正常。如果剩余节点不足多数派,集群无法选出新 Leader,系统会进入不可写甚至不可服务状态,直到多数节点恢复。 --- 下一篇:[07 - 分布式事务基础](./07-distributed-tx-basics.md)
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入