ZooKeeper共享锁怎么创建

# ZooKeeper共享锁怎么创建

## 前言

在分布式系统中，协调多个节点对共享资源的访问是一个常见且具有挑战性的问题。ZooKeeper高可用的分布式协调服务，提供了强大的原语来实现分布式锁。本文将深入探讨如何使用ZooKeeper创建**共享锁（Shared Lock）**，包括实现原理、核心步骤和完整代码示例。

---

## 一、ZooKeeper分布式锁基础

### 1.1 分布式锁的类型
- **排他锁（Exclusive Lock）**：同一时间只有一个客户端能持有锁
- **共享锁（Shared Lock）**：允许多个客户端同时读取资源，但写入时需要独占访问

### 1.2 ZooKeeper实现锁的优势
- 顺序一致性保证
- 临时节点（Ephemeral Nodes）自动清理
- Watch机制实现阻塞等待

---

## 二、共享锁实现原理

### 2.1 核心设计思路
1. 所有锁请求都创建**顺序临时节点**在同一个父节点下

/locks/shared_lock_00000001 /locks/shared_lock_00000002

2. 节点命名区分锁类型：
   - `READ_`前缀表示读锁
   - `WRITE_`前缀表示写锁

### 2.2 获取锁的规则
- **读锁**：如果没有更早的写锁请求，可以立即获取
- **写锁**：必须等待所有更早的节点（无论读写）都释放

### 2.3 释放锁机制
客户端完成操作后主动删除自己创建的节点，或会话结束自动清理临时节点。

---

## 三、完整实现步骤

### 3.1 环境准备
```java
// ZooKeeper客户端初始化
ZooKeeper zk = new ZooKeeper("localhost:2181", 3000, watcher);

3.2 创建锁节点

String lockPath = zk.create("/locks/shared_lock_", 
                           null,
                           ZooDefs.Ids.OPEN_ACL_UNSAFE,
                           CreateMode.EPHEMERAL_SEQUENTIAL);

3.3 实现读锁获取逻辑

public boolean acquireReadLock() throws KeeperException, InterruptedException {
    // 1. 获取所有已存在的锁节点
    List<String> children = zk.getChildren("/locks", false);
    
    // 2. 检查是否有更早的写锁
    for (String node : children) {
        if (node.startsWith("WRITE_") && 
            node.compareTo(myNode) < 0) {
            // 注册Watcher并等待
            return false;
        }
    }
    
    // 3. 无冲突则获取锁成功
    return true;
}

3.4 实现写锁获取逻辑

public boolean acquireWriteLock() throws KeeperException, InterruptedException {
    // 1. 获取所有已存在的锁节点
    List<String> children = zk.getChildren("/locks", false);
    
    // 2. 检查是否是序号最小的节点
    Collections.sort(children);
    if (!myNode.equals(children.get(0))) {
        // 注册Watcher并等待
        return false;
    }
    
    return true;
}

3.5 锁释放实现

public void releaseLock() throws KeeperException, InterruptedException {
    zk.delete(lockPath, -1);
}

3.6 完整等待逻辑（Watcher实现）

Watcher lockWatcher = new Watcher() {
    public void process(WatchedEvent event) {
        synchronized(this) {
            notifyAll(); // 唤醒等待线程
        }
    }
};

while (!acquireLock()) {
    synchronized(lockWatcher) {
        lockWatcher.wait();
    }
}

四、关键问题与解决方案

4.1 惊群效应（Herd Effect）

问题：大量客户端同时监听同一个节点的删除事件
解决方案：只监听比自己序号小的最近节点

4.2 锁公平性问题

优化：使用FIFO队列机制，ZooKeeper的顺序节点天然支持

4.3 客户端崩溃处理

保障：依靠临时节点的会话关联特性自动释放

五、完整代码示例

public class ZooKeeperSharedLock {
    private final ZooKeeper zk;
    private final String lockBasePath;
    private String lockPath;
    
    public ZooKeeperSharedLock(ZooKeeper zk, String lockBasePath) {
        this.zk = zk;
        this.lockBasePath = lockBasePath;
    }
    
    public boolean acquireReadLock() throws Exception {
        lockPath = zk.create(lockBasePath + "/READ_", 
                           null,
                           ZooDefs.Ids.OPEN_ACL_UNSAFE,
                           CreateMode.EPHEMERAL_SEQUENTIAL);
                           
        while (true) {
            List<String> children = zk.getChildren(lockBasePath, false);
            Collections.sort(children);
            
            String earliestWrite = null;
            for (String node : children) {
                if (node.startsWith("WRITE_")) {
                    earliestWrite = node;
                    break;
                }
            }
            
            if (earliestWrite == null || 
                lockPath.compareTo(earliestWrite) < 0) {
                return true;
            }
            
            // 等待前一个节点释放
            final CountDownLatch latch = new CountDownLatch(1);
            Stat stat = zk.exists(lockBasePath + "/" + earliestWrite, 
                                event -> {
                                    if (event.getType() == EventType.NodeDeleted) {
                                        latch.countDown();
                                    }
                                });
            if (stat != null) {
                latch.await();
            }
        }
    }
    
    // 其他方法实现...
}

六、性能优化建议

1. 连接复用：避免每次获取锁都创建新连接
2. 本地缓存：缓存子节点列表减少ZK查询
3. 锁超时：添加超时机制防止死等
4. 锁重入：支持同一线程重复获取锁

七、与其他方案的对比

结语

通过ZooKeeper实现共享锁虽然需要处理较多细节，但提供了极强的可靠性和一致性保证。在实际生产环境中，建议使用Curator等高级客户端库，它们已经封装了完善的分布式锁实现（如InterProcessReadWriteLock）。理解底层原理将帮助开发者更好地应对各种分布式协调场景。

注：本文示例代码需要根据实际业务场景进行调整，生产环境建议添加完善的异常处理和重试机制。 “`