Zookeeper的应用场景有哪些

Zookeeper 在分布式系统中扮演着非常重要的角色，它不仅仅用于配置管理，还涉及到分布式锁、服务发现、集群管理等多个方面。以下是 Zookeeper 的一些常见应用场景及其具体实现方法，包含代码示例。

---

1. 分布式配置管理

Zookeeper 提供了一个简单且强大的配置管理机制。在分布式系统中，多个服务可能需要共享一些配置参数（如数据库连接信息、文件路径等），Zookeeper 通过节点存储配置，并通过 Watcher 机制通知所有客户端当配置发生变更时及时更新。

实现步骤：

1. 将配置存储在 Zookeeper 的某个 ZNode 下。
2. 客户端使用 Watcher 监控配置节点的变化。
3. 当配置发生变化时，客户端通过 Watcher 获取新配置并更新。

示例：

假设我们有一个分布式应用需要动态管理数据库配置，我们可以把这些配置存储在 Zookeeper 中的 /config/db 路径下。

配置存储节点：

$ zkCli.sh
[zk: localhost:2181(CONNECTED) 0] create /config/db '{"host": "localhost", "port": 3306}'

Java 客户端监控配置变化：

import org.apache.zookeeper.*;

public class ZookeeperConfigWatcher implements Watcher {
    private static ZooKeeper zk;
    private static String configPath = "/config/db";

    public static void main(String[] args) throws Exception {
        // 初始化Zookeeper客户端
        zk = new ZooKeeper("localhost:2181", 3000, new ZookeeperConfigWatcher());
        
        // 获取当前配置
        String config = new String(zk.getData(configPath, true, null));
        System.out.println("Current config: " + config);
        
        // 在配置节点上设置Watcher监听配置变更
        zk.exists(configPath, true);
        
        // 保持程序运行，以便监听配置变化
        Thread.sleep(Long.MAX_VALUE);
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == Event.EventType.NodeDataChanged) {
            try {
                // 配置变更时读取新数据
                String updatedConfig = new String(zk.getData(configPath, false, null));
                System.out.println("Updated config: " + updatedConfig);
                
                // 重新设置Watcher
                zk.exists(configPath, true);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

使用说明：

1. 上述代码会初始化一个 Zookeeper 客户端，连接到本地 Zookeeper 服务。
2. 客户端读取 /config/db 路径下的配置信息，并设置 Watcher 监听该节点的变化。
3. 当配置发生变化时，process 方法会被触发，客户端会自动获取新配置并更新。

---

2. 分布式锁

Zookeeper 通过临时顺序节点可以实现分布式锁。临时顺序节点确保了在某个节点宕机后，其他节点能自动感知并重新争抢锁，避免了因节点宕机而导致的死锁情况。

实现步骤：

1. 客户端创建一个临时顺序节点，节点名称中包含顺序编号。
2. 客户端检查自己创建的节点是否是最小编号的节点。如果是，获取锁。
3. 如果不是，客户端监视比自己编号小的节点，当它被删除时，客户端重新获取锁。

示例：

Java 实现分布式锁：

import org.apache.zookeeper.*;

import java.util.Collections;
import java.util.List;

public class ZookeeperDistributedLock {
    private static ZooKeeper zk;
    private static String lockPath = "/lock";
    private static String currentNode;

    public static void main(String[] args) throws Exception {
        // 初始化Zookeeper客户端
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理Watcher事件
            }
        });
        
        // 创建临时顺序节点
        currentNode = zk.create(lockPath + "/lock-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        
        // 获取锁
        getLock();
        
        // 模拟持有锁的业务逻辑
        Thread.sleep(5000);
        
        // 释放锁
        releaseLock();
    }

    private static void getLock() throws Exception {
        // 获取锁路径下的所有子节点
        List<String> children = zk.getChildren(lockPath, false);
        Collections.sort(children); // 排序节点，最小的顺序节点获取锁

        String firstNode = children.get(0);
        if (currentNode.endsWith(firstNode)) {
            System.out.println("Lock acquired!");
        } else {
            String prevNode = children.get(children.indexOf(currentNode.substring(lockPath.length())) - 1);
            zk.exists(lockPath + "/" + prevNode, new Watcher() {
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        try {
                            getLock(); // 前一个节点被删除时，尝试重新获取锁
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }

    private static void releaseLock() throws Exception {
        zk.delete(currentNode, -1);
        System.out.println("Lock released!");
    }
}

使用说明：

1. 客户端创建一个临时顺序节点，Zookeeper 会为每个客户端生成一个唯一的顺序节点名。
2. 客户端获取锁时，会检查自己创建的节点是否是最小编号的节点。如果是，它就可以获取锁；如果不是，它将监视比自己顺序编号小的节点，等待其删除后尝试重新获取锁。
3. 当任务完成后，客户端会删除自己创建的临时顺序节点，从而释放锁。

---

3. 服务发现

Zookeeper 在分布式系统中广泛应用于服务发现机制。服务发现指的是在分布式环境中，动态地查询服务的可用实例并进行负载均衡。Zookeeper 可以通过其提供的节点存储和 Watcher 机制，动态管理服务实例。

实现步骤：

1. 将所有服务实例注册到 Zookeeper 中，每个服务实例对应一个 ZNode。
2. 客户端通过 Watcher 监控服务节点的变化，获取可用的服务实例列表。
3. 当服务新增或删除时，客户端能够动态地发现新的服务。

示例：

服务实例注册：

$ zkCli.sh
[zk: localhost:2181(CONNECTED) 0] create /services/myapp/service1 "Service 1"
[zk: localhost:2181(CONNECTED) 1] create /services/myapp/service2 "Service 2"

Java 客户端获取服务实例：

import org.apache.zookeeper.*;

import java.util.List;

public class ZookeeperServiceDiscovery {
    private static ZooKeeper zk;
    private static String servicePath = "/services/myapp";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 监控服务实例变化
                if (event.getType() == Event.EventType.NodeChildrenChanged) {
                    try {
                        getServiceInstances(); // 获取更新后的服务实例列表
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        // 获取服务实例
        getServiceInstances();
        
        // 保持客户端运行
        Thread.sleep(Long.MAX_VALUE);
    }

    private static void getServiceInstances() throws Exception {
        List<String> serviceInstances = zk.getChildren(servicePath, true); // true 表示设置Watcher
        System.out.println("Current available services: " + serviceInstances);
    }
}

使用说明：

1. 将服务实例（如 service1, service2）注册到 /services/myapp 路径下。
2. 客户端通过 zk.getChildren() 获取该路径下所有的子节点，这些子节点代表了当前活跃的服务实例。
3. 客户端通过设置 Watcher，当服务节点发生变化（如新增、删除）时，能够动态获取服务实例列表并更新。

---

4. 分布式队列

Zookeeper 还可以实现分布式队列。在这种场景下，多个消费者从队列中取任务并执行，Zookeeper 确保任务顺序和公平性。

实现步骤：

1. 每个任务是一个 ZNode，节点的创建顺序确保任务的排队顺序。
2. 客户端根据顺序号取任务，取到最小顺序号的节点进行处理。
3. 处理完任务后，删除对应的 ZNode。

---

5. Leader 选举

Zookeeper 常用于实现分布式系统中的 Leader 选举。Leader 选举用于确保在分布式环境中某一时刻只有一个节点被选举为 Leader，通常用于保证对资源的独占访问。其他节点（Follower）则等待 Leader 的指示，通常在数据库或任务调度系统中会使用 Leader 选举来避免竞争条件。

实现步骤：

1. 节点尝试创建一个临时顺序节点。
2. 节点检查自己是否是最小的顺序节点。
3. 如果是，成为 Leader。如果不是，则监听比自己顺序编号小的节点，等待它被删除后重新参与选举。

示例：

Java 实现 Leader 选举：

import org.apache.zookeeper.*;

import java.util.Collections;
import java.util.List;

public class ZookeeperLeaderElection {
    private static ZooKeeper zk;
    private static String electPath = "/leader";
    private static String currentNode;

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });
        
        // 创建临时顺序节点
        currentNode = zk.create(electPath + "/node-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        
        // 选举Leader
        electLeader();
        
        // 模拟执行Leader任务
        Thread.sleep(5000);
        
        // 释放Leader
        releaseLeader();
    }

    private static void electLeader() throws Exception {
        List<String> children = zk.getChildren(electPath, false);
        Collections.sort(children); // 排序节点，最小编号的节点成为Leader

        String firstNode = children.get(0);
        if (currentNode.endsWith(firstNode)) {
            System.out.println("I am the Leader!");
        } else {
            String prevNode = children.get(children.indexOf(currentNode.substring(electPath.length())) - 1);
            zk.exists(electPath + "/" + prevNode, new Watcher() {
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        try {
                            electLeader(); // 前一个节点被删除时，尝试重新选举Leader
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }

    private static void releaseLeader() throws Exception {
        zk.delete(currentNode, -1);
        System.out.println("Released Leader role.");
    }
}

说明：

• 这个例子中，通过创建临时顺序节点（/leader/node-）来进行选举，节点会在节点列表中排序，最小编号的节点被选为 Leader。
• 如果当前节点不是最小的编号，它会监听比自己编号小的节点，当该节点被删除时，当前节点会尝试重新成为 Leader。

---

6. 分布式计数器

Zookeeper 还可以用来实现分布式计数器。这通常用于在多个节点间共享一个递增的计数值。Zookeeper 提供的 临时顺序节点 可以帮助实现计数器，保证计数的顺序性和一致性。

实现步骤：

1. 每个增量操作创建一个临时顺序节点。
2. 节点的顺序值表示当前的计数值。

示例：

Java 实现分布式计数器：

import org.apache.zookeeper.*;

public class ZookeeperDistributedCounter {
    private static ZooKeeper zk;
    private static String counterPath = "/counter";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });
        
        // 创建计数器
        createCounter();
        
        // 递增计数器
        incrementCounter();
        
        // 获取计数器值
        getCounterValue();
    }

    private static void createCounter() throws Exception {
        if (zk.exists(counterPath, false) == null) {
            zk.create(counterPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    private static void incrementCounter() throws Exception {
        String nodeName = zk.create(counterPath + "/node-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("Incremented Counter: " + nodeName);
    }

    private static void getCounterValue() throws Exception {
        List<String> children = zk.getChildren(counterPath, false);
        System.out.println("Current Counter Value: " + children.size());
    }
}

说明：

• 该代码实现了一个分布式计数器，通过创建临时顺序节点 (/counter/node-) 来递增计数器。
• 每次创建新的临时顺序节点时，节点的顺序号自动递增。通过获取 /counter 路径下的所有子节点数量，获取当前计数器的值。

---

7. 分布式任务调度

在分布式系统中，任务调度器常常需要协调不同节点的任务执行。Zookeeper 可用于任务的调度和管理，确保任务的分配是有序和高效的。例如，Zookeeper 可以用来确保每个任务只有一个节点在执行，从而避免重复执行。

实现步骤：

1. 为每个任务创建一个 ZNode。
2. 各个节点轮流获取任务并执行，确保任务的有序调度。
3. 节点执行完任务后删除任务 ZNode，表示任务完成。

示例：

Java 实现分布式任务调度：

import org.apache.zookeeper.*;

public class ZookeeperTaskScheduler {
    private static ZooKeeper zk;
    private static String taskPath = "/tasks";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });
        
        // 创建任务路径
        createTaskPath();
        
        // 调度任务
        scheduleTask();
        
        // 保持客户端运行
        Thread.sleep(Long.MAX_VALUE);
    }

    private static void createTaskPath() throws Exception {
        if (zk.exists(taskPath, false) == null) {
            zk.create(taskPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    private static void scheduleTask() throws Exception {
        // 创建任务节点
        String taskNode = zk.create(taskPath + "/task-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("Task created: " + taskNode);
        
        // 获取所有任务节点并排序
        List<String> tasks = zk.getChildren(taskPath, false);
        Collections.sort(tasks);  // 确保任务按照顺序执行
        
        String taskToExecute = taskPath + "/" + tasks.get(0);
        System.out.println("Executing task: " + taskToExecute);
        
        // 执行任务（这里只是打印任务信息，实际应用可以做更复杂的操作）
        zk.delete(taskToExecute, -1);
        System.out.println("Task completed and removed: " + taskToExecute);
    }
}

说明：

• 任务调度过程中，每个任务都被创建为一个临时顺序节点，节点顺序决定任务的执行顺序。
• 节点在执行完任务后会被删除，确保任务不会被重复执行。

---

8. 全局唯一ID生成

在分布式系统中，经常需要生成全局唯一的 ID。Zookeeper 提供的临时顺序节点可以帮助生成全局唯一的 ID，通过创建顺序节点来实现 ID 的递增。

实现步骤：

1. 在某个路径下创建临时顺序节点。
2. 通过顺序节点的编号来生成唯一 ID。

示例：

Java 实现全局唯一 ID 生成：

import org.apache.zookeeper.*;

public class ZookeeperUniqueIDGenerator {
    private static ZooKeeper zk;
    private static String idPath = "/unique_id";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });
        
        // 创建唯一ID路径
        createIDPath();
        
        // 生成唯一ID
        generateUniqueID();
    }

    private static void createIDPath() throws Exception {
        if (zk.exists(idPath, false) == null) {
            zk.create(idPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
       

 }
    }

    private static void generateUniqueID() throws Exception {
        String idNode = zk.create(idPath + "/id-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("Generated unique ID: " + idNode);
    }
}

说明：

• 每次生成 ID 时，都会在 /unique_id/id- 路径下创建一个临时顺序节点。通过节点的顺序号来生成全局唯一的 ID。

---

9. 分布式队列（高并发任务分发）

Zookeeper 可以用于实现分布式队列，它可以帮助多个生产者和消费者协作，通过分布式节点存储队列数据并确保任务按顺序执行。在高并发的场景下，Zookeeper 可以有效管理任务的分发，保证任务顺序和公平性。

实现步骤：

1. 生产者将任务数据放入 Zookeeper 中，创建一个任务节点。
2. 消费者获取最早的任务并处理，处理完成后删除该节点。
3. Zookeeper 保证任务的顺序性和节点的独占性。

示例：

Java 实现分布式队列：

import org.apache.zookeeper.*;

import java.util.List;
import java.util.Collections;

public class ZookeeperDistributedQueue {
    private static ZooKeeper zk;
    private static String queuePath = "/queue";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });
        
        // 创建队列路径
        createQueuePath();
        
        // 生产者入队
        enqueue("task1");
        enqueue("task2");
        
        // 消费者出队并处理
        dequeue();
    }

    private static void createQueuePath() throws Exception {
        if (zk.exists(queuePath, false) == null) {
            zk.create(queuePath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    private static void enqueue(String task) throws Exception {
        String taskNode = zk.create(queuePath + "/task-", task.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        System.out.println("Enqueued task: " + taskNode);
    }

    private static void dequeue() throws Exception {
        List<String> tasks = zk.getChildren(queuePath, false);
        Collections.sort(tasks);  // 确保任务顺序执行
        
        if (!tasks.isEmpty()) {
            String taskToProcess = tasks.get(0);
            byte[] taskData = zk.getData(queuePath + "/" + taskToProcess, false, null);
            System.out.println("Processing task: " + new String(taskData));
            
            // 删除已处理的任务
            zk.delete(queuePath + "/" + taskToProcess, -1);
            System.out.println("Processed and removed task: " + taskToProcess);
        }
    }
}

说明：

• 通过创建顺序节点，每个任务都会在队列中有一个唯一的位置。消费者根据任务顺序（即节点的编号）获取任务。
• 任务处理完成后，消费者删除任务节点，确保任务不会被重复消费。

---

10. 服务协调与健康检查

Zookeeper 作为一个高可用的分布式系统协调服务，能够帮助进行 服务协调 和 健康检查。在微服务架构中，Zookeeper 可以用于管理各个服务实例的健康状态，自动将健康服务加入到负载均衡池中。

实现步骤：

1. 各服务节点定期更新自己的健康状态到 Zookeeper 中。
2. 如果某个服务失效，它的健康状态会被 Zookeeper 监控并移除。
3. 客户端或负载均衡器通过 Zookeeper 查询健康的服务实例。

示例：

Java 实现服务健康检查：

import org.apache.zookeeper.*;
import java.util.List;

public class ZookeeperServiceHealthCheck {
    private static ZooKeeper zk;
    private static String servicePath = "/services";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 注册服务实例（健康检查）
        registerService("service1");
        registerService("service2");

        // 定期检查健康状态
        checkServiceHealth();
        
        // 保持客户端运行
        Thread.sleep(Long.MAX_VALUE);
    }

    private static void registerService(String serviceName) throws Exception {
        String serviceNode = zk.create(servicePath + "/" + serviceName, "healthy".getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println(serviceName + " registered with Zookeeper");
    }

    private static void checkServiceHealth() throws Exception {
        List<String> services = zk.getChildren(servicePath, new Watcher() {
            public void process(WatchedEvent event) {
                // 重新检查健康状态
                try {
                    checkServiceHealth();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        
        System.out.println("Currently available services: " + services);
        
        for (String service : services) {
            byte[] status = zk.getData(servicePath + "/" + service, false, null);
            System.out.println(service + " status: " + new String(status));
        }
    }
}

说明：

• 服务实例通过 Zookeeper 注册，并设置为临时节点。
• 健康检查机制通过 getData 获取服务的健康状态数据，客户端实时监控服务状态变化。
• 如果某个服务挂掉，Zookeeper 会自动删除其临时节点，负载均衡器就可以检测到服务的失效。

---

11. 分布式屏障（Barrier）

分布式屏障（Barrier）是一种同步原语，它可以确保所有参与者在达到某个条件后才能继续执行。例如，多个节点需要等待其他节点都准备好后才开始执行某个任务。Zookeeper 可以很好地实现这一功能，确保所有节点在同步点都达到一致，然后才能继续执行。

实现步骤：

1. 每个节点在进入屏障时，会在 Zookeeper 中创建一个临时节点。
2. 当所有节点都到达同步点（即所有临时节点都创建）后，才允许所有节点继续执行。
3. Zookeeper 会监控这些临时节点的数量，当数量达到预定值时，解除阻塞。

示例：

Java 实现分布式屏障：

import org.apache.zookeeper.*;

import java.util.List;

public class ZookeeperDistributedBarrier {
    private static ZooKeeper zk;
    private static String barrierPath = "/barrier";
    private static int totalParticipants = 3;  // 假设有3个参与者

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 创建屏障路径
        createBarrierPath();

        // 节点加入屏障
        joinBarrier("node1");
        joinBarrier("node2");
        joinBarrier("node3");

        // 等待所有节点加入屏障
        waitForAllNodes();
    }

    private static void createBarrierPath() throws Exception {
        if (zk.exists(barrierPath, false) == null) {
            zk.create(barrierPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    private static void joinBarrier(String nodeName) throws Exception {
        zk.create(barrierPath + "/" + nodeName, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
        System.out.println(nodeName + " reached the barrier");
    }

    private static void waitForAllNodes() throws Exception {
        List<String> children = zk.getChildren(barrierPath, false);
        
        while (children.size() < totalParticipants) {
            System.out.println("Waiting for other nodes...");
            Thread.sleep(1000);
            children = zk.getChildren(barrierPath, false);  // 重新获取子节点
        }

        System.out.println("All nodes reached the barrier, continuing execution...");
    }
}

说明：

• 每个节点通过在 Zookeeper 中创建临时节点加入到屏障路径 /barrier 下。
• 其他节点会检查当前屏障下的节点数量，直到达到预期的参与者数量，才解除阻塞，继续执行。

---

12. 状态机和分布式一致性

Zookeeper 可用于实现分布式一致性，保证不同节点在分布式系统中的状态一致。常见的应用包括分布式数据存储的原子操作和事务日志的同步。Zookeeper 可以作为一个分布式协调者，确保所有节点执行一致的操作。

应用场景：

• 分布式数据库的日志同步。
• 分布式状态同步，如全局配置信息的分发和一致性。
• 分布式事务管理。

---

13. 分布式锁

分布式锁用于保证在多个进程或节点并发执行时，某些操作能够在同一时刻只能由一个节点执行。Zookeeper 可以非常方便地实现分布式锁，常见的应用场景包括数据库操作、文件写入、任务调度等。

实现步骤：

1. 创建一个临时顺序节点表示锁。
2. 尝试创建节点，如果成功，表示获得锁；如果失败，监听前一个节点的删除事件，等待前一个节点释放锁。
3. 释放锁时，删除自己创建的节点。

示例：

Java 实现分布式锁：

import org.apache.zookeeper.*;

import java.util.Collections;
import java.util.List;

public class ZookeeperDistributedLock {
    private static ZooKeeper zk;
    private static String lockPath = "/lock";
    private static String currentNode;

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 尝试获取锁
        getLock();
        
        // 执行任务
        System.out.println("Lock acquired, executing task...");
        Thread.sleep(5000);
        
        // 释放锁
        releaseLock();
    }

    private static void getLock() throws Exception {
        currentNode = zk.create(lockPath + "/node-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("Attempting to acquire lock: " + currentNode);

        // 获取锁的顺序节点
        List<String> children = zk.getChildren(lockPath, false);
        Collections.sort(children); // 排序

        String firstNode = children.get(0);
        if (currentNode.endsWith(firstNode)) {
            System.out.println("Lock acquired: " + currentNode);
        } else {
            String prevNode = children.get(children.indexOf(currentNode.substring(lockPath.length())) - 1);
            zk.exists(lockPath + "/" + prevNode, new Watcher() {
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        try {
                            getLock(); // 前一个节点被删除时，尝试重新获取锁
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
        }
    }

    private static void releaseLock() throws Exception {
        zk.delete(currentNode, -1);
        System.out.println("Lock released: " + currentNode);
    }
}

说明：

• 通过创建临时顺序节点实现分布式锁，节点会根据顺序号确定哪个节点能够获取锁。
• 如果当前节点不是最小的顺序节点，它会监听比自己顺序编号小的节点，等待其删除后才能获取锁。

---

14. 分布式配置管理

Zookeeper 可以作为一个集中式配置管理系统，管理分布式应用中的配置信息。Zookeeper 保证配置数据的高可用性和一致性，多个节点可以从 Zookeeper 中获取配置数据，而当配置发生变化时，Zookeeper 可以通过 Watcher 通知客户端。

实现步骤：

1. 在 Zookeeper 中存储配置信息，使用持久化节点。
2. 客户端获取配置信息，并设置 Watcher，当配置发生变化时，自动更新配置。

示例：

Java 实现分布式配置管理：

import org.apache.zookeeper.*;

import java.util.concurrent.CountDownLatch;

public class ZookeeperConfigManager {
    private static ZooKeeper zk;
    private static String configPath = "/config/db_config";

    public static void main(String[] args) throws Exception {
        CountDownLatch latch = new CountDownLatch(1);
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                if (event.getType() == Event.EventType.NodeDataChanged) {
                    System.out.println("Config updated: " + event.getPath());
                    try {
                        // 配置发生变化时重新获取配置
                        getConfig();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });

        // 等待连接建立
        latch.await();

        // 获取配置信息
        getConfig();

        // 模拟配置更新
        updateConfig("db_config", "new_database_config");
    }

    private static void getConfig() throws Exception {
        byte[] configData = zk.getData(configPath, true, null); // 设置Watcher
        System.out.println("Current Config: " + new String(configData));
    }

    private static void updateConfig(String path, String config) throws Exception {
        if (zk.exists(configPath, false) == null) {
            zk.create(configPath, config.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            zk.setData(configPath, config.getBytes(), -1);
        }
        System.out.println("Config updated to: " + config);
    }
}

说明：

• 客户端通过 getData 获取配置信息，并设置 Watcher 来监听配置的变化。
• 配置发生变化时，Zookeeper 会通过 Watcher 通知客户端，客户端可以自动更新配置信息。

---

15. 分布式数据存储

Zookeeper 也可以作为一个轻量级的分布式数据存储系统，用于存储小量的配置信息、元数据、状态信息等。虽然 Zookeeper 主要用于协调，但它的高可用性和一致性也使其在一些场景中可以作为数据存储使用。

实现步骤：

1. 使用 Zookeeper 存储数据，可以存储小的配置信息、状态等。
2. Zookeeper 会保证数据一致性，节点的创建、修改、删除操作是原子性的。

示例：

Java 实现分布式数据存储：

import org.apache.zookeeper.*;

public class ZookeeperDistributedDataStore {
    private static ZooKeeper zk;
    private static String dataPath = "/data";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 存储数据
        storeData("key1", "value1");

        // 获取数据
        getData("key1");
    }

    private static void storeData(String key, String value) throws Exception {
        String nodePath = dataPath + "/" + key;
        if (zk.exists(nodePath, false) == null) {
            zk.create(nodePath, value.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        } else {
            zk.setData(nodePath, value.getBytes(), -1);
        }
        System.out.println("Stored data: " + key + " = " + value);
    }

    private static void getData(String key) throws Exception {
        String nodePath = dataPath + "/" + key;
        byte[] data = zk.getData(nodePath, false, null);
        System.out.println("Retrieved data: " + key + " = " + new String(data));
    }
}

说明：

• Zookeeper 被用作简单的分布式数据存储，通过创建持久化节点存储数据，保证了数据的一致性。
• 数据更新和读取时，Zookeeper 会确保所有客户端看到的数据是一致的。

---

16. 分布式事务

Zookeeper 支持通过事务日志和原子操作来实现分布式事务处理。虽然 Zookeeper 本身并不是专门用于分布式事务，但它可以帮助协调分布式系统中的事务状态，确保一致性。

实现步骤：

1. 使用 Zookeeper 存储分布式事务的状态（例如，事务的各个阶段）。
2. 各个节点根据事务的状态进行操作，确保整个事务的一致性。

应用场景：

• 分布式数据库的一致性协议（如两段提交、三段提交等）。
• 分布式任务的协调和回滚。

---

17. 基于 Zookeeper 的分布式 MapReduce

在分布式计算框架中，Zookeeper 常用于协调和管理任务的分配。类似于 Hadoop 等 MapReduce 系统，Zookeeper 可以作为调度器来管理任务的分发、状态跟踪以及任务的失败恢复等。

应用场景：

• 大数据计算任务的调度与监控。
• 任务分配和任务状态跟踪。

---

18. 分布式版本控制

Zookeeper 可以用于实现分布式版本控制系统。通过在 Zookeeper 中存储版本信息，并使用临时节点来表示版本的状态，多个分布式节点可以协调一致地处理版本的更新和检查

。

---

19. 分布式自动化部署与更新

Zookeeper 可以用于协调和管理大规模分布式系统中的自动化部署和配置更新。例如，在一个微服务架构中，你可能需要通过 Zookeeper 来管理每个服务的部署状态，并协调服务的更新。

实现步骤：

1. 服务节点将自己的部署状态（例如，版本号、状态）存储在 Zookeeper 中。
2. 更新操作可以通过 Zookeeper 来同步，使得多个节点按顺序进行部署或配置更新，避免出现不一致或冲突的情况。

示例：

Java 实现自动化部署与更新：

import org.apache.zookeeper.*;

public class ZookeeperDistributedDeployment {
    private static ZooKeeper zk;
    private static String deployPath = "/deployment";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 模拟部署
        deployService("service1", "v1.0");
        deployService("service2", "v1.1");

        // 查看部署状态
        checkDeploymentStatus("service1");
        checkDeploymentStatus("service2");
    }

    private static void deployService(String serviceName, String version) throws Exception {
        String servicePath = deployPath + "/" + serviceName;
        if (zk.exists(servicePath, false) == null) {
            zk.create(servicePath, version.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("Deployed " + serviceName + " with version: " + version);
        } else {
            zk.setData(servicePath, version.getBytes(), -1);
            System.out.println("Updated " + serviceName + " to version: " + version);
        }
    }

    private static void checkDeploymentStatus(String serviceName) throws Exception {
        String servicePath = deployPath + "/" + serviceName;
        byte[] version = zk.getData(servicePath, false, null);
        System.out.println("Current version of " + serviceName + ": " + new String(version));
    }
}

说明：

• 服务的版本信息被存储在 Zookeeper 中，多个节点可以通过 Zookeeper 获取当前的部署版本，避免不同版本的服务同时运行，造成冲突。
• 这种方式可以有效地实现集中式的服务部署管理，并保持所有节点的一致性。

---

20. 跨数据中心同步和故障恢复

Zookeeper 可以帮助跨数据中心或跨区域的分布式系统进行同步。在某些场景中，可能需要保证在多个数据中心之间的数据一致性和可靠性。Zookeeper 的强一致性和高可用性使得它非常适合处理跨数据中心的协调任务，例如在主从复制、全局负载均衡等场景下提供协调支持。

应用场景：

• 跨区域数据库同步。
• 多数据中心的负载均衡和健康检查。
• 灾难恢复：确保在主数据中心出现故障时，能够快速切换到备用数据中心。

---

21. 分布式数据一致性保障（类似 Paxos 或 Raft）

Zookeeper 本身实现了类似 Paxos 或 Raft 的协议，以保证在分布式系统中数据的一致性。虽然 Zookeeper 本身并不是一个完整的分布式数据库系统，但它为一致性保障提供了基础设施。你可以利用 Zookeeper 实现分布式系统中的一些核心一致性特性，例如状态同步、配置一致性和协调。

实现步骤：

1. 使用 Zookeeper 创建多个协作节点，确保所有节点在状态更新时的一致性。
2. 通过顺序节点、临时节点等机制来实现节点之间的同步和一致性保障。

示例：

Java 实现分布式一致性保障：

import org.apache.zookeeper.*;

public class ZookeeperConsistency {
    private static ZooKeeper zk;
    private static String consensusPath = "/consensus";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 模拟分布式一致性操作
        createConsensusNode("node1", "value1");
        createConsensusNode("node2", "value2");

        // 获取一致性结果
        getConsensusData();
    }

    private static void createConsensusNode(String nodeName, String value) throws Exception {
        String nodePath = consensusPath + "/" + nodeName;
        if (zk.exists(nodePath, false) == null) {
            zk.create(nodePath, value.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            System.out.println("Created consensus node: " + nodeName + " with value: " + value);
        }
    }

    private static void getConsensusData() throws Exception {
        byte[] data = zk.getData(consensusPath + "/node1", false, null);
        System.out.println("Consensus value from node1: " + new String(data));
        
        data = zk.getData(consensusPath + "/node2", false, null);
        System.out.println("Consensus value from node2: " + new String(data));
    }
}

说明：

• 通过 Zookeeper 的顺序节点和一致性保证，可以在多个节点之间同步数据，确保在分布式系统中所有节点看到的一致的状态。
• 这在保证跨多个节点或者区域的系统一致性时非常有用。

---

22. 分布式消息队列

Zookeeper 可以用于构建一个简易的分布式消息队列。在高并发的分布式系统中，消息队列通常用于解耦生产者和消费者，Zookeeper 提供了强一致性保障，使得多个消费者可以按照顺序消费消息，同时确保消息不会丢失。

实现步骤：

1. 消费者监听消息队列路径，并处理消息。
2. 生产者将消息存储为临时节点，确保消息处理的顺序。
3. 消费者消费完消息后删除相应的节点。

示例：

Java 实现简易的分布式消息队列：

import org.apache.zookeeper.*;

import java.util.List;
import java.util.Collections;

public class ZookeeperDistributedQueue {
    private static ZooKeeper zk;
    private static String queuePath = "/message_queue";

    public static void main(String[] args) throws Exception {
        zk = new ZooKeeper("localhost:2181", 3000, new Watcher() {
            public void process(WatchedEvent event) {
                // 处理事件
            }
        });

        // 创建队列路径
        createQueuePath();

        // 生产者入队
        enqueue("message1");
        enqueue("message2");

        // 消费者出队并处理
        dequeue();
    }

    private static void createQueuePath() throws Exception {
        if (zk.exists(queuePath, false) == null) {
            zk.create(queuePath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    private static void enqueue(String message) throws Exception {
        String messageNode = zk.create(queuePath + "/msg-", message.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT_SEQUENTIAL);
        System.out.println("Enqueued message: " + messageNode);
    }

    private static void dequeue() throws Exception {
        List<String> messages = zk.getChildren(queuePath, false);
        Collections.sort(messages);  // 确保按顺序处理消息
        
        if (!messages.isEmpty()) {
            String messageToProcess = messages.get(0);
            byte[] messageData = zk.getData(queuePath + "/" + messageToProcess, false, null);
            System.out.println("Processing message: " + new String(messageData));
            
            // 删除已处理的消息
            zk.delete(queuePath + "/" + messageToProcess, -1);
            System.out.println("Processed and removed message: " + messageToProcess);
        }
    }
}

说明：

• 通过创建顺序节点，消息排队并确保顺序消费。每个节点代表一个消息，消费者按顺序处理消息。
• Zookeeper 提供的顺序节点能够保证消息的严格顺序，并且如果消费者挂掉，Zookeeper 的 Watcher 机制可以确保消息的恢复。

---

23. 分布式分析系统（实时数据处理）

在大数据或实时数据处理系统中，Zookeeper 被广泛应用于协调和管理数据流。Zookeeper 可以帮助分布式分析系统（如 Apache Storm 或 Apache Flink）中的节点进行状态同步、任务分配等操作。

应用场景：

• 分布式数据流的任务调度和监控。
• 实时计算中多个节点的任务协调和同步。
• 确保计算节点之间数据一致性。

---

24. 分布式锁 + 任务调度

结合分布式锁和 Zookeeper 的节点删除/监听机制，可以实现分布式任务调度。Zookeeper 可以协调哪些节点执行任务并保证任务的独占性，防止多个节点重复执行同一个任务。

---

以上是 Zookeeper 在分布式系统中的一些常见应用场景。通过它的强一致性保障、分布式协调和高可用性，Zookeeper 被广泛用于各种系统中，尤其是在需要保证数据一致性和系统高可用的场景。