ZooKeeper 五种经典应用场景详解

最新推荐文章于 2025-11-29 20:27:37 发布
原创 最新推荐文章于 2025-11-29 20:27:37 发布 · 799 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#zookeeper #wpf #分布式

ZooKeeper 五种经典应用场景详解

目录

  1. 分布式锁（Distributed Lock）
  2. 配置管理（Configuration Management）
  3. 服务注册与发现（Service Registration and Discovery）
  4. Leader选举（Leader Election）
  5. 分布式队列（Distributed Queue）

1. 分布式锁

简介

分布式锁是 ZooKeeper 最经典的应用场景之一，用于在分布式系统中实现互斥访问共享资源。通过 ZooKeeper 的临时顺序节点（Ephemeral Sequential Node）特性，可以实现公平的分布式锁机制。

架构图

锁节点结构
应用集群
ZooKeeper集群
创建临时顺序节点
创建临时顺序节点
创建临时顺序节点
监听前一个节点
监听前一个节点
lock根节点
lock-0000000001
lock-0000000002
lock-0000000003
应用实例1
应用实例2
应用实例3
ZooKeeper Node 1
ZooKeeper Node 2
ZooKeeper Node 3

示例代码

Java 实现
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.locks.InterProcessMutex;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.TimeUnit;

public class DistributedLockExample {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String LOCK_PATH = "/distributed-lock";
  
    private CuratorFramework client;
    private InterProcessMutex lock;
  
    public DistributedLockExample() {
        // 创建 Curator 客户端
        client = CuratorFrameworkFactory.builder()
                .connectString(ZK_ADDRESS)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        client.start();
      
        // 创建分布式锁
        lock = new InterProcessMutex(client, LOCK_PATH);
    }
  
    /**
     * 获取锁并执行业务逻辑
     */
    public void doWorkWithLock() {
        try {
            // 尝试获取锁，最多等待10秒
            if (lock.acquire(10, TimeUnit.SECONDS)) {
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取到锁");
                    // 执行业务逻辑
                    doBusinessLogic();
                } finally {
                    // 释放锁
                    lock.release();
                    System.out.println(Thread.currentThread().getName() + " 释放锁");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
  
    private void doBusinessLogic() throws InterruptedException {
        // 模拟业务处理
        Thread.sleep(2000);
        System.out.println("执行业务逻辑...");
    }
  
    public void close() {
        if (client != null) {
            client.close();
        }
    }
  
    public static void main(String[] args) {
        DistributedLockExample example = new DistributedLockExample();
      
        // 模拟多个线程竞争锁
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            new Thread(() -> {
                example.doWorkWithLock();
            }, "Thread-" + threadId).start();
        }
      
        try {
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
      
        example.close();
    }
}
原生 ZooKeeper API 实现
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class NativeDistributedLock {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String LOCK_ROOT = "/locks";
    private static final String LOCK_PREFIX = "lock-";
  
    private ZooKeeper zk;
    private String lockPath;
    private String currentLockPath;
  
    public NativeDistributedLock() throws IOException, InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });
        latch.await();
      
        // 确保根节点存在
        try {
            if (zk.exists(LOCK_ROOT, false) == null) {
                zk.create(LOCK_ROOT, new byte[0], 
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (KeeperException e) {
            // 节点已存在，忽略
        }
    }
  
    /**
     * 获取锁
     */
    public boolean tryLock() throws KeeperException, InterruptedException {
        // 创建临时顺序节点
        currentLockPath = zk.create(LOCK_ROOT + "/" + LOCK_PREFIX, 
            new byte[0], 
            ZooDefs.Ids.OPEN_ACL_UNSAFE, 
            CreateMode.EPHEMERAL_SEQUENTIAL);
      
        // 获取所有锁节点并排序
        List<String> children = zk.getChildren(LOCK_ROOT, false);
        Collections.sort(children);
      
        // 判断当前节点是否是最小的节点
        String currentNode = currentLockPath.substring(LOCK_ROOT.length() + 1);
        int index = children.indexOf(currentNode);
      
        if (index == 0) {
            // 当前节点是最小的，获取锁成功
            return true;
        } else {
            // 监听前一个节点
            String previousNode = LOCK_ROOT + "/" + children.get(index - 1);
            final CountDownLatch latch = new CountDownLatch(1);
          
            Stat stat = zk.exists(previousNode, event -> {
                if (event.getType() == Watcher.Event.EventType.NodeDeleted) {
                    latch.countDown();
                }
            });
          
            if (stat == null) {
                // 前一个节点已不存在，重新尝试获取锁
                return tryLock();
            }
          
            // 等待前一个节点被删除
            latch.await();
            return tryLock();
        }
    }
  
    /**
     * 释放锁
     */
    public void unlock() throws KeeperException, InterruptedException {
        if (currentLockPath != null) {
            zk.delete(currentLockPath, -1);
            currentLockPath = null;
        }
    }
  
    public void close() throws InterruptedException {
        if (zk != null) {
            zk.close();
        }
    }
}

重难点分析

重点：

  1. 临时顺序节点：使用 EPHEMERAL_SEQUENTIAL 模式创建节点，确保节点按顺序创建且会话断开时自动删除
  2. 公平锁机制：通过节点序号实现公平锁，序号最小的节点获得锁
  3. 监听机制：通过监听前一个节点的删除事件，实现锁的自动获取

难点：

  1. 惊群效应：多个客户端同时监听同一个节点，当节点删除时所有客户端都会被唤醒。解决方案是只监听前一个节点
  2. 会话超时：客户端会话超时会导致临时节点被删除，可能影响锁的正确性。需要实现会话重连机制
  3. 死锁检测：需要处理客户端异常退出导致的锁无法释放问题（临时节点会自动删除，但需要确保会话正常关闭）

2. 配置管理

简介

配置管理是 ZooKeeper 的另一个重要应用场景，用于集中管理分布式系统的配置信息。当配置发生变化时，所有订阅该配置的客户端都能实时收到通知并更新本地配置。

架构图

应用集群
配置管理服务
ZooKeeper集群
写入配置
监听配置变化
监听配置变化
监听配置变化
配置变更通知
配置变更通知
配置变更通知
应用实例1
应用实例2
应用实例3
配置管理服务
ZooKeeper集群
config/app-config节点

示例代码

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.NodeCache;
import org.apache.curator.framework.recipes.cache.NodeCacheListener;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.nio.charset.StandardCharsets;

public class ConfigManager {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String CONFIG_PATH = "/config/app-config";
  
    private CuratorFramework client;
    private NodeCache nodeCache;
    private String currentConfig;
  
    public ConfigManager() {
        client = CuratorFrameworkFactory.builder()
                .connectString(ZK_ADDRESS)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        client.start();
      
        // 创建节点缓存监听器
        nodeCache = new NodeCache(client, CONFIG_PATH);
        nodeCache.getListenable().addListener(new NodeCacheListener() {
            @Override
            public void nodeChanged() throws Exception {
                updateConfig();
            }
        });
      
        try {
            nodeCache.start(true);
            updateConfig();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
  
    /**
     * 更新配置
     */
    private void updateConfig() {
        try {
            byte[] data = nodeCache.getCurrentData().getData();
            currentConfig = new String(data, StandardCharsets.UTF_8);
            System.out.println("配置已更新: " + currentConfig);
            // 应用新配置
            applyConfig(currentConfig);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
  
    /**
     * 应用配置到业务逻辑
     */
    private void applyConfig(String config) {
        // 解析配置并应用到业务逻辑
        System.out.println("应用配置: " + config);
        // 例如：更新数据库连接池大小、线程池参数等
    }
  
    /**
     * 获取当前配置
     */
    public String getCurrentConfig() {
        return currentConfig;
    }
  
    /**
     * 更新配置（管理员操作）
     */
    public void updateConfig(String newConfig) throws Exception {
        client.setData().forPath(CONFIG_PATH, newConfig.getBytes(StandardCharsets.UTF_8));
    }
  
    /**
     * 初始化配置
     */
    public void initConfig(String initialConfig) throws Exception {
        try {
            client.create().creatingParentsIfNeeded()
                    .forPath(CONFIG_PATH, initialConfig.getBytes(StandardCharsets.UTF_8));
        } catch (Exception e) {
            // 节点已存在，直接更新
            updateConfig(initialConfig);
        }
    }
  
    public void close() {
        if (nodeCache != null) {
            try {
                nodeCache.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (client != null) {
            client.close();
        }
    }
  
    public static void main(String[] args) throws Exception {
        ConfigManager configManager = new ConfigManager();
      
        // 初始化配置
        configManager.initConfig("{\"threadPoolSize\": 10, \"dbPoolSize\": 20}");
      
        // 模拟配置更新
        Thread.sleep(5000);
        configManager.updateConfig("{\"threadPoolSize\": 20, \"dbPoolSize\": 30}");
      
        Thread.sleep(10000);
        configManager.close();
    }
}

重难点分析

重点：

  1. 实时通知：使用 NodeCache 或 PathChildrenCache 监听配置节点变化
  2. 配置版本管理：通过节点版本号实现配置的版本控制
  3. 配置回滚：保存历史配置，支持配置回滚

难点：

  1. 配置一致性：确保所有节点在同一时刻看到相同的配置。需要处理网络分区和节点故障的情况
  2. 配置冲突：多个管理员同时修改配置时的冲突处理。可以使用乐观锁（版本号）机制
  3. 配置格式：需要定义统一的配置格式（JSON、XML、Properties等），并处理格式错误的情况

3. 服务注册与发现

简介

服务注册与发现是微服务架构中的核心组件。服务提供者将自己的服务信息注册到 ZooKeeper，服务消费者从 ZooKeeper 获取可用的服务列表，实现服务的动态发现和负载均衡。

架构图

服务消费者
服务提供者
ZooKeeper集群
注册服务
注册服务
注册服务
发现服务
发现服务
调用
调用
调用
消费者1
消费者2
用户服务实例1
用户服务实例2
订单服务实例1
ZooKeeper集群
services根节点
user-service
order-service
user-service-provider-1
user-service-provider-2
order-service-provider-1

示例代码

服务注册
import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.cache.PathChildrenCache;
import org.apache.curator.framework.recipes.cache.PathChildrenCacheListener;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.net.InetAddress;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;

public class ServiceRegistry {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICES_ROOT = "/services";
  
    private CuratorFramework client;
    private String serviceName;
    private String servicePath;
    private String currentProviderPath;
  
    public ServiceRegistry(String serviceName) {
        this.serviceName = serviceName;
        this.servicePath = SERVICES_ROOT + "/" + serviceName;
      
        client = CuratorFrameworkFactory.builder()
                .connectString(ZK_ADDRESS)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        client.start();
    }
  
    /**
     * 注册服务
     */
    public void register(String host, int port) throws Exception {
        // 确保服务根节点存在
        try {
            if (client.checkExists().forPath(SERVICES_ROOT) == null) {
                client.create().creatingParentsIfNeeded()
                        .forPath(SERVICES_ROOT);
            }
        } catch (Exception e) {
            // 节点已存在
        }
      
        // 创建服务提供者节点（临时节点）
        String providerInfo = host + ":" + port;
        currentProviderPath = client.create()
                .creatingParentsIfNeeded()
                .withMode(CreateMode.EPHEMERAL_SEQUENTIAL)
                .forPath(servicePath + "/provider-", 
                        providerInfo.getBytes(StandardCharsets.UTF_8));
      
        System.out.println("服务注册成功: " + currentProviderPath + " -> " + providerInfo);
    }
  
    /**
     * 注销服务
     */
    public void unregister() {
        if (currentProviderPath != null) {
            try {
                client.delete().forPath(currentProviderPath);
                System.out.println("服务注销成功: " + currentProviderPath);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
  
    public void close() {
        unregister();
        if (client != null) {
            client.close();
        }
    }
}
服务发现
public class ServiceDiscovery {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String SERVICES_ROOT = "/services";
  
    private CuratorFramework client;
    private String serviceName;
    private String servicePath;
    private PathChildrenCache pathChildrenCache;
    private List<String> serviceProviders;
  
    public ServiceDiscovery(String serviceName) {
        this.serviceName = serviceName;
        this.servicePath = SERVICES_ROOT + "/" + serviceName;
        this.serviceProviders = new ArrayList<>();
      
        client = CuratorFrameworkFactory.builder()
                .connectString(ZK_ADDRESS)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        client.start();
      
        // 监听服务提供者列表变化
        pathChildrenCache = new PathChildrenCache(client, servicePath, true);
        pathChildrenCache.getListenable().addListener(new PathChildrenCacheListener() {
            @Override
            public void childEvent(CuratorFramework client, PathChildrenCacheEvent event) 
                    throws Exception {
                updateServiceProviders();
            }
        });
      
        try {
            pathChildrenCache.start();
            updateServiceProviders();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
  
    /**
     * 更新服务提供者列表
     */
    private void updateServiceProviders() {
        try {
            List<String> providers = new ArrayList<>();
            List<String> children = client.getChildren().forPath(servicePath);
          
            for (String child : children) {
                String childPath = servicePath + "/" + child;
                byte[] data = client.getData().forPath(childPath);
                String providerInfo = new String(data, StandardCharsets.UTF_8);
                providers.add(providerInfo);
            }
          
            synchronized (this) {
                serviceProviders = providers;
            }
          
            System.out.println("服务列表已更新: " + serviceProviders);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
  
    /**
     * 获取服务提供者列表
     */
    public synchronized List<String> getServiceProviders() {
        return new ArrayList<>(serviceProviders);
    }
  
    /**
     * 负载均衡：随机选择一个服务提供者
     */
    public String getRandomProvider() {
        List<String> providers = getServiceProviders();
        if (providers.isEmpty()) {
            return null;
        }
        int index = (int) (Math.random() * providers.size());
        return providers.get(index);
    }
  
    /**
     * 负载均衡：轮询选择服务提供者
     */
    private int roundRobinIndex = 0;
    public String getRoundRobinProvider() {
        List<String> providers = getServiceProviders();
        if (providers.isEmpty()) {
            return null;
        }
        String provider = providers.get(roundRobinIndex % providers.size());
        roundRobinIndex++;
        return provider;
    }
  
    public void close() {
        if (pathChildrenCache != null) {
            try {
                pathChildrenCache.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (client != null) {
            client.close();
        }
    }
}

重难点分析

重点：

  1. 临时节点：使用临时节点存储服务提供者信息，服务下线时自动删除
  2. 动态监听：使用 PathChildrenCache 监听服务列表变化，实现服务的动态发现
  3. 负载均衡：实现多种负载均衡策略（随机、轮询、一致性哈希等）

难点：

  1. 服务健康检查：ZooKeeper 只能检测到会话断开，无法检测服务是否真正可用。需要结合心跳机制或健康检查接口
  2. 服务雪崩：当大量服务同时注册或注销时，可能触发大量事件。需要实现事件合并和防抖机制
  3. 网络分区：网络分区可能导致服务注册信息不一致。需要实现分区恢复后的数据同步机制

4. Leader选举

简介

Leader 选举是分布式系统中的经典问题，用于在多个节点中选出一个主节点来协调工作。ZooKeeper 通过临时顺序节点和最小序号机制，可以优雅地实现 Leader 选举。

架构图

应用节点集群
ZooKeeper集群
创建临时顺序节点
创建临时顺序节点
创建临时顺序节点
Leader
Follower
Follower
监听前一个节点
监听前一个节点
应用节点1
应用节点2
应用节点3
ZooKeeper集群
election根节点
node-0000000001
node-0000000002
node-0000000003

示例代码

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.leader.LeaderLatch;
import org.apache.curator.framework.recipes.leader.LeaderLatchListener;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.util.concurrent.TimeUnit;

public class LeaderElectionExample {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String ELECTION_PATH = "/election";
  
    private CuratorFramework client;
    private LeaderLatch leaderLatch;
    private String nodeId;
  
    public LeaderElectionExample(String nodeId) {
        this.nodeId = nodeId;
      
        client = CuratorFrameworkFactory.builder()
                .connectString(ZK_ADDRESS)
                .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                .build();
        client.start();
      
        leaderLatch = new LeaderLatch(client, ELECTION_PATH, nodeId);
        leaderLatch.addListener(new LeaderLatchListener() {
            @Override
            public void isLeader() {
                System.out.println("节点 " + nodeId + " 成为 Leader");
                startLeaderWork();
            }
          
            @Override
            public void notLeader() {
                System.out.println("节点 " + nodeId + " 不再是 Leader");
                stopLeaderWork();
            }
        });
    }
  
    /**
     * 参与选举
     */
    public void start() throws Exception {
        leaderLatch.start();
    }
  
    /**
     * 检查是否是 Leader
     */
    public boolean isLeader() {
        return leaderLatch.hasLeadership();
    }
  
    /**
     * 等待成为 Leader（带超时）
     */
    public boolean awaitLeadership(long timeout, TimeUnit unit) throws InterruptedException {
        return leaderLatch.await(timeout, unit);
    }
  
    /**
     * Leader 的工作
     */
    private void startLeaderWork() {
        System.out.println("节点 " + nodeId + " 开始执行 Leader 工作");
        // 例如：定时任务调度、数据同步等
    }
  
    /**
     * 停止 Leader 工作
     */
    private void stopLeaderWork() {
        System.out.println("节点 " + nodeId + " 停止 Leader 工作");
    }
  
    /**
     * 退出选举
     */
    public void close() throws Exception {
        if (leaderLatch != null) {
            leaderLatch.close();
        }
        if (client != null) {
            client.close();
        }
    }
  
    public static void main(String[] args) throws Exception {
        // 创建多个节点参与选举
        LeaderElectionExample node1 = new LeaderElectionExample("node-1");
        LeaderElectionExample node2 = new LeaderElectionExample("node-2");
        LeaderElectionExample node3 = new LeaderElectionExample("node-3");
      
        node1.start();
        node2.start();
        node3.start();
      
        // 等待选举完成
        Thread.sleep(2000);
      
        // 检查 Leader
        if (node1.isLeader()) {
            System.out.println("Node-1 是 Leader");
        }
        if (node2.isLeader()) {
            System.out.println("Node-2 是 Leader");
        }
        if (node3.isLeader()) {
            System.out.println("Node-3 是 Leader");
        }
      
        // 模拟 Leader 节点退出
        Thread.sleep(5000);
        if (node1.isLeader()) {
            node1.close();
            System.out.println("Leader 节点退出，重新选举...");
        }
      
        Thread.sleep(2000);
      
        // 清理
        node1.close();
        node2.close();
        node3.close();
    }
}
使用原生 API 实现 Leader 选举
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class NativeLeaderElection implements Watcher {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String ELECTION_ROOT = "/election";
    private static final String NODE_PREFIX = "node-";
  
    private ZooKeeper zk;
    private String currentNodePath;
    private String watchedNodePath;
    private boolean isLeader = false;
    private LeaderElectionListener listener;
  
    public interface LeaderElectionListener {
        void onElected();
        void onRevoked();
    }
  
    public NativeLeaderElection(LeaderElectionListener listener) 
            throws IOException, InterruptedException {
        this.listener = listener;
      
        CountDownLatch latch = new CountDownLatch(1);
        zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });
        latch.await();
      
        // 确保根节点存在
        try {
            if (zk.exists(ELECTION_ROOT, false) == null) {
                zk.create(ELECTION_ROOT, new byte[0], 
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (KeeperException e) {
            // 节点已存在
        }
    }
  
    /**
     * 参与选举
     */
    public void participate() throws KeeperException, InterruptedException {
        // 创建临时顺序节点
        currentNodePath = zk.create(ELECTION_ROOT + "/" + NODE_PREFIX, 
            new byte[0], 
            ZooDefs.Ids.OPEN_ACL_UNSAFE, 
            CreateMode.EPHEMERAL_SEQUENTIAL);
      
        checkAndBecomeLeader();
    }
  
    /**
     * 检查并成为 Leader
     */
    private void checkAndBecomeLeader() throws KeeperException, InterruptedException {
        List<String> children = zk.getChildren(ELECTION_ROOT, false);
        Collections.sort(children);
      
        String currentNode = currentNodePath.substring(ELECTION_ROOT.length() + 1);
        int index = children.indexOf(currentNode);
      
        if (index == 0) {
            // 当前节点是最小的，成为 Leader
            if (!isLeader) {
                isLeader = true;
                System.out.println("成为 Leader: " + currentNodePath);
                if (listener != null) {
                    listener.onElected();
                }
            }
        } else {
            // 不是 Leader，监听前一个节点
            if (isLeader) {
                isLeader = false;
                System.out.println("不再是 Leader: " + currentNodePath);
                if (listener != null) {
                    listener.onRevoked();
                }
            }
          
            String previousNode = ELECTION_ROOT + "/" + children.get(index - 1);
            watchNode(previousNode);
        }
    }
  
    /**
     * 监听节点
     */
    private void watchNode(String nodePath) throws KeeperException, InterruptedException {
        watchedNodePath = nodePath;
        Stat stat = zk.exists(nodePath, this);
        if (stat == null) {
            // 前一个节点已不存在，重新检查
            checkAndBecomeLeader();
        }
    }
  
    @Override
    public void process(WatchedEvent event) {
        if (event.getType() == Event.EventType.NodeDeleted) {
            if (event.getPath().equals(watchedNodePath)) {
                try {
                    checkAndBecomeLeader();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
  
    /**
     * 检查是否是 Leader
     */
    public boolean isLeader() {
        return isLeader;
    }
  
    public void close() throws InterruptedException {
        if (zk != null) {
            zk.close();
        }
    }
}

重难点分析

重点：

  1. 最小序号机制：序号最小的节点成为 Leader，简单高效
  2. 自动故障转移：Leader 节点故障时，下一个节点自动成为新的 Leader
  3. 临时节点：使用临时节点确保节点故障时自动从选举中移除

难点：

  1. 脑裂问题：网络分区可能导致多个 Leader 同时存在。需要结合其他机制（如 fencing token）来防止脑裂
  2. 选举风暴：大量节点同时参与选举时可能产生大量事件。需要优化监听机制
  3. Leader 切换开销：Leader 切换时可能需要重新加载状态、重建连接等，需要最小化切换开销

5. 分布式队列

简介

分布式队列用于在分布式系统中实现任务队列，支持多生产者多消费者模式。ZooKeeper 可以通过顺序节点和监听机制实现分布式队列。

架构图

消费者
生产者
ZooKeeper集群
生产任务
生产任务
消费任务
消费任务
被消费
被消费
消费者1
消费者2
生产者1
生产者2
ZooKeeper集群
queue根节点
item-0000000001
item-0000000002
item-0000000003

示例代码

import org.apache.curator.framework.CuratorFramework;
import org.apache.curator.framework.CuratorFrameworkFactory;
import org.apache.curator.framework.recipes.queue.DistributedQueue;
import org.apache.curator.framework.recipes.queue.QueueBuilder;
import org.apache.curator.framework.recipes.queue.QueueConsumer;
import org.apache.curator.framework.recipes.queue.QueueSerializer;
import org.apache.curator.retry.ExponentialBackoffRetry;

import java.nio.charset.StandardCharsets;

public class DistributedQueueExample {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String QUEUE_PATH = "/distributed-queue";
  
    /**
     * 队列序列化器
     */
    public static class StringQueueSerializer implements QueueSerializer<String> {
        @Override
        public byte[] serialize(String item) {
            return item.getBytes(StandardCharsets.UTF_8);
        }
      
        @Override
        public String deserialize(byte[] bytes) {
            return new String(bytes, StandardCharsets.UTF_8);
        }
    }
  
    /**
     * 队列消费者
     */
    public static class StringQueueConsumer implements QueueConsumer<String> {
        private String consumerName;
      
        public StringQueueConsumer(String consumerName) {
            this.consumerName = consumerName;
        }
      
        @Override
        public void consumeMessage(String message) throws Exception {
            System.out.println(consumerName + " 消费消息: " + message);
            // 处理消息
            processMessage(message);
        }
      
        @Override
        public void stateChanged(CuratorFramework client, ConnectionState newState) {
            System.out.println(consumerName + " 连接状态变化: " + newState);
        }
      
        private void processMessage(String message) {
            // 模拟消息处理
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
  
    /**
     * 生产者
     */
    public static class QueueProducer {
        private CuratorFramework client;
        private DistributedQueue<String> queue;
      
        public QueueProducer() {
            client = CuratorFrameworkFactory.builder()
                    .connectString(ZK_ADDRESS)
                    .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                    .build();
            client.start();
          
            queue = QueueBuilder.builder(client, 
                    new StringQueueConsumer("Producer"), 
                    new StringQueueSerializer(), 
                    QUEUE_PATH)
                    .buildQueue();
          
            try {
                queue.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
      
        public void put(String message) throws Exception {
            queue.put(message);
            System.out.println("生产消息: " + message);
        }
      
        public void close() throws Exception {
            if (queue != null) {
                queue.close();
            }
            if (client != null) {
                client.close();
            }
        }
    }
  
    /**
     * 消费者
     */
    public static class QueueConsumer {
        private CuratorFramework client;
        private DistributedQueue<String> queue;
        private StringQueueConsumer consumer;
      
        public QueueConsumer(String consumerName) {
            consumer = new StringQueueConsumer(consumerName);
          
            client = CuratorFrameworkFactory.builder()
                    .connectString(ZK_ADDRESS)
                    .retryPolicy(new ExponentialBackoffRetry(1000, 3))
                    .build();
            client.start();
          
            queue = QueueBuilder.builder(client, 
                    consumer, 
                    new StringQueueSerializer(), 
                    QUEUE_PATH)
                    .buildQueue();
          
            try {
                queue.start();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
      
        public void close() throws Exception {
            if (queue != null) {
                queue.close();
            }
            if (client != null) {
                client.close();
            }
        }
    }
  
    public static void main(String[] args) throws Exception {
        // 创建生产者
        QueueProducer producer = new QueueProducer();
      
        // 创建多个消费者
        QueueConsumer consumer1 = new QueueConsumer("Consumer-1");
        QueueConsumer consumer2 = new QueueConsumer("Consumer-2");
        QueueConsumer consumer3 = new QueueConsumer("Consumer-3");
      
        // 生产消息
        for (int i = 0; i < 10; i++) {
            producer.put("Message-" + i);
            Thread.sleep(500);
        }
      
        // 等待消费完成
        Thread.sleep(20000);
      
        // 清理
        producer.close();
        consumer1.close();
        consumer2.close();
        consumer3.close();
    }
}
使用原生 API 实现简单队列
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;

public class SimpleDistributedQueue {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final String QUEUE_ROOT = "/queue";
    private static final String ITEM_PREFIX = "item-";
  
    private ZooKeeper zk;
  
    public SimpleDistributedQueue() throws IOException, InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        zk = new ZooKeeper(ZK_ADDRESS, 3000, event -> {
            if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
                latch.countDown();
            }
        });
        latch.await();
      
        // 确保根节点存在
        try {
            if (zk.exists(QUEUE_ROOT, false) == null) {
                zk.create(QUEUE_ROOT, new byte[0], 
                    ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        } catch (KeeperException e) {
            // 节点已存在
        }
    }
  
    /**
     * 入队
     */
    public void offer(byte[] data) throws KeeperException, InterruptedException {
        zk.create(QUEUE_ROOT + "/" + ITEM_PREFIX, 
            data, 
            ZooDefs.Ids.OPEN_ACL_UNSAFE, 
            CreateMode.PERSISTENT_SEQUENTIAL);
    }
  
    /**
     * 出队（阻塞）
     */
    public byte[] take() throws KeeperException, InterruptedException {
        while (true) {
            List<String> children = zk.getChildren(QUEUE_ROOT, false);
            if (children.isEmpty()) {
                // 队列为空，等待
                final CountDownLatch latch = new CountDownLatch(1);
                zk.getChildren(QUEUE_ROOT, event -> {
                    if (event.getType() == Watcher.Event.EventType.NodeChildrenChanged) {
                        latch.countDown();
                    }
                });
                latch.await();
                continue;
            }
          
            // 排序并获取最小的节点
            Collections.sort(children);
            String firstChild = children.get(0);
            String firstChildPath = QUEUE_ROOT + "/" + firstChild;
          
            try {
                byte[] data = zk.getData(firstChildPath, false, null);
                zk.delete(firstChildPath, -1);
                return data;
            } catch (KeeperException.NoNodeException e) {
                // 节点已被其他消费者删除，重试
                continue;
            }
        }
    }
  
    /**
     * 出队（非阻塞）
     */
    public byte[] poll() throws KeeperException, InterruptedException {
        List<String> children = zk.getChildren(QUEUE_ROOT, false);
        if (children.isEmpty()) {
            return null;
        }
      
        Collections.sort(children);
        String firstChild = children.get(0);
        String firstChildPath = QUEUE_ROOT + "/" + firstChild;
      
        try {
            byte[] data = zk.getData(firstChildPath, false, null);
            zk.delete(firstChildPath, -1);
            return data;
        } catch (KeeperException.NoNodeException e) {
            return null;
        }
    }
  
    /**
     * 获取队列大小
     */
    public int size() throws KeeperException, InterruptedException {
        return zk.getChildren(QUEUE_ROOT, false).size();
    }
  
    public void close() throws InterruptedException {
        if (zk != null) {
            zk.close();
        }
    }
}

重难点分析

重点：

  1. FIFO 保证：通过顺序节点和排序机制保证先进先出
  2. 并发安全：多个消费者同时消费时的并发控制
  3. 阻塞消费：队列为空时消费者阻塞等待

难点：

  1. 重复消费：多个消费者可能同时获取到同一个消息。需要使用原子操作（如 getData + delete 的原子性）或分布式锁
  2. 消息丢失：消费者获取消息后但在处理前崩溃，可能导致消息丢失。可以使用临时节点或事务机制
  3. 性能优化：大量消息时的性能问题。可以考虑批量操作、异步处理等优化手段

总结

ZooKeeper 作为分布式协调服务，在上述五种场景中都发挥了重要作用：

  1. 分布式锁：解决分布式环境下的互斥访问问题
  2. 配置管理：实现配置的集中管理和动态更新
  3. 服务注册与发现：支持微服务架构中的服务治理
  4. Leader 选举：实现分布式系统中的主从切换
  5. 分布式队列：提供分布式环境下的任务队列功能

通用最佳实践

  1. 使用 Curator 框架：Curator 提供了更高级的抽象，简化了 ZooKeeper 的使用
  2. 处理连接断开：实现重连机制和状态恢复
  3. 监控和日志：记录关键操作，便于问题排查
  4. 性能优化：合理使用缓存、批量操作等优化手段
  5. 错误处理：妥善处理各种异常情况，确保系统稳定性

注意事项

  • ZooKeeper 不适合存储大量数据，主要用于协调和元数据管理
  • 注意会话超时设置，避免因网络抖动导致节点被误删
  • 合理设置监听器，避免监听风暴
  • 考虑 ZooKeeper 的性能限制，对于高并发场景需要结合其他技术
ZooKeeper工作机制与应用场景
giser@2011的博客
05-08 1330
Apache ZooKeeper 是一个开源的分布式协调服务，它为分布式应用提供一致性服务。ZooKeeper 维持一个简单的数据结构类似于文件系统，使得分布式系统可以协调它们的动作，确保数据的一致性和完整性。ZooKeeper 是一个典型的分布式数据一致性解决方案，分布式应用程序可以基于ZooKeeper 实现诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列等功能。
Zookeeper数据结构与集群架构详解
qq_45061342的博客
08-16 2235
ZooKeeper 是一个开源的分布式协调框架，是Apache Hadoop 的一个子项目，主要用来解决分布式集群中应用系统的一致性问题。Zookeeper 的设计目标是将那些复杂且容易出错的分布式一致性服务封装起来，构成一个高效可靠的原语集，并以一系列简单易用的接口提供给用户使用。ZooKeeper本质上是一个分布式的小文件存储系统（Zookeeper=文件系统+监听机制）。提供基于类似于文件系统的目录树方式的数据存储，并且可以对树中的节点进行有效管理，从而用来维护和监控存储的数据的状态变化。
ZooKeeper架构及应用场景详解
走过冬季
05-29 1111
专注于提供协调原语（节点、Watch、一致性），应用基于这些构建块实现复杂功能。集群部署，容错性强。Zab 协议保证写操作的全局顺序和一致性，对协调至关重要。读操作可由任意节点处理，吞吐量高；写性能在保证一致性的前提下也足够好。实现了高效的状态变更通知，避免了低效的轮询。天然与服务/客户端生命周期绑定，简化了服务发现、成员管理等场景的实现。ZooKeeper 通过其独特的树形数据模型（ZNode）基于临时节点和 Watch 的事件驱动机制、以及Zab 协议保证的强一致性（顺序一致性）
【ZooKeeper】ZooKeeper 应用场景
一梦
10-10 1986
ZooKeeper 应用场景
Zookeeper八种应用场景
cnzzs的博客
01-19 845
ZooKeeper八种典型应用场景详细介绍为进一步加强对 zk 的认识，理解 zk 的作用，下面再详细介绍一下 zk 在生产环境中的典型应用场景。1. 配置维护1.1 什么是配置维护分布式系统中，很多服务都是部署在集群中的，即多台服务器中部署着完全相同的应用，起着完全相同的作用。当然，集群中的这些服务器的配置文件是完...
Zookeeper六大应用场景详解
热门推荐
LoveSummer
04-06 4万+
在通常的Java开发编程中，有两种常⻅的⽅式可以用来定义锁，分别是synchronized机制和JDK5提供的 ReentrantLock。和排他锁⼀样，同样是通过 ZooKeeper 上的数据节点来表示⼀个锁，是⼀个类似于 “/shared_lock/[Hostname]-请求类型-序号”的临时顺序节点，例如。
Paxos算法与ZooKeeper应用详解
weixin_45422672的博客
05-23 728
Paxos算法作为分布式一致性领域的经典协议，为解决分布式系统中的共识问题提供了坚实的理论基础。ZooKeeper通过ZAB协议对Paxos算法进行了优化和扩展，使其更适应主从架构的协调服务场景。ZAB协议引入的Leader角色、ZXID事务ID机制和同步阶段，有效解决了Paxos算法中的提案竞争、事务顺序性和恢复机制等问题，提高了系统的活性和性能。随着分布式系统的发展，Paxos算法及其变体（如ZAB、Multi-Paxos等）将继续发挥重要作用。
ZooKeeper详解以及应用部署（AI）
秉承初心博客
06-12 1291
ZooKeeper是一个分布式协调服务框架，提供数据一致性保障和关键协调功能。其核心包括主从集群架构（Leader/Follower/Observer）、全局数据一致性和原子性更新机制。数据模型采用树形ZNode结构，支持持久/临时/顺序节点。关键机制有Watcher监听、ZAB协议选举和脑裂防护。典型应用包括配置管理、分布式锁、服务注册等。部署方式支持单机和集群模式，需配置Java环境、数据目录和防火墙规则。运维方面提供ACL权限管理、数据备份和Prometheus监控支持。ZooKeeper简化了分布式
一文讲透大数据领域Zookeeper的应用场景
AI天才研究院
08-19 1138
在数字化时代，数据量呈爆炸式增长，单一服务器早已无法满足处理海量数据的需求。分布式系统通过将任务分散到多个节点协同工作，极大地提升了计算能力和存储容量。节点通信不可靠：网络延迟、丢包、分区等问题随时可能发生节点故障常态化：硬件故障、软件崩溃、网络中断等情况屡见不鲜数据一致性挑战：多节点间如何保持数据同步是个棘手问题并发控制难题：多个进程同时操作共享资源时如何避免冲突状态管理复杂：系统整体状态分散在多个节点，难以全局掌握。
zookeeper学习、配置文件参数详解
weixin_48053866的博客
06-18 2867
ZooKeeper 是一个分布式协调服务，它可以维护配置信息、命名空间、分布式同步等。ZooKeeper 的配置文件通常是 zoo.cfg，这个文件中包含了 ZooKeeper 运行所需要的配置信息。
ZooKeeper 典型的应用场景详解
05-26
### ZooKeeper 典型的应用场景详解 #### 一、引言 ZooKeeper是一个高度可用的协调服务，用于分布式应用程序中的管理和同步。它基于观察者模式设计，通过存储和管理共享数据来支持集群间的协作。当这些数据发生改变...
【分布式系统】ZooKeeper集群管理与协调服务详解：面试专题及应用场景解析介绍了ZooKeeper
04-20
适合人群：对分布式系统有兴趣的技术人员，尤其是那些希望深入了解ZooKeeper工作原理及其应用场景的研发人员。 使用场景及目标：①理解ZooKeeper如何作为分布式系统的协调者，确保集群中各节点间的同步与通信；②...
【分布式系统】Zookeeper核心概念与技术要点详解：面试题汇总及应用场景分析文档的主要内容
05-15
内容概要：本文档详细介绍了ZooKeeper的核心概念、特性和应用场景。ZooKeeper是一个开源的分布式协调服务，主要用于管理集群节点状态，提供诸如数据发布/订阅、负载均衡、命名服务、分布式协调/通知、集群管理、...
【分布式系统】Zookeeper核心概念、安装配置与应用场景详解：从0到1掌握分布式协调服务Zookeeper在分布式
07-27
最后，通过统一配置管理、分布式锁实现和服务注册与发现三个实际应用场景展示了Zookeeper的强大功能，并讨论了常见的问题与解决方案。 适用人群：对分布式系统有一定了解的技术人员，尤其是希望深入了解Zookeeper...
【Zookeeper】监听器原理
qq_43494013的博客
11-29 128
【Zookeeper】监听器原理
【Zookeeper】 Zookeeper入门
qq_43494013的博客
11-29 180
【Zookeeper】 Zookeeper入门
【Zookeeper】CAP理论——BASE定理及ZK追求的一致性
qq_43494013的博客
11-29 106
【Zookeeper】CAP理论——BASE定理及ZK追求的一致性
【Zookeeper】客户端命令行——节点类型
qq_43494013的博客
11-29 86
【Zookeeper】客户端命令行——节点类型
【Zookeeper】zk_客户端API_创建节点
最新发布
qq_43494013的博客
11-29 103
【Zookeeper】zk_客户端API_创建节点
ZooKeeper应用场景详解及实战演示
### Zookeeper应用场景 1. **Master选举** 在分布式系统中，为了提高系统的可用性和可靠性，通常会有多个相同的服务器同时工作，并且在它们之间选举出一个主服务器（Master）来协调工作。Zookeeper可以用来在多个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值