基于ZooKeeper的分布式锁

2. 基于ZooKeeper的分布式锁

ZooKeeper 是一个分布式协调服务，提供了一套完善的分布式原语，可以用来实现分布式锁。基于 ZooKeeper 实现的分布式锁主要依赖于其顺序节点和监听机制。

实现步骤：

1. 客户端请求获取锁时，创建一个顺序临时节点。
2. 客户端获取父节点下所有的子节点，并监视比自己小的那个节点。
3. 如果发现自己是最小的节点，则表示获取到了锁，可以执行业务逻辑。
4. 如果发现自己不是最小的节点，则等待监听的节点被删除，然后重复步骤 2。

优点：

• 锁的获取和释放是原子操作，能够确保强一致性。
• 支持细粒度的锁。

缺点：

• 实现相对复杂，对 ZooKeeper 的依赖性较强。
• 性能可能不如基于 Redis 的实现方式。

下面是一个基于 ZooKeeper 的分布式锁的 Java 代码示例：

import org.apache.zookeeper.*;

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

public class ZooKeeperDistributedLock implements Watcher {
    private ZooKeeper zooKeeper;
    private String rootNode = "/locks";
    private String lockName;
    private String lockPath;
    private CountDownLatch countDownLatch;

    public ZooKeeperDistributedLock(String host, int sessionTimeout, String lockName) throws IOException {
        this.lockName = lockName;
        countDownLatch = new CountDownLatch(1);
        zooKeeper = new ZooKeeper(host, sessionTimeout, this);
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void lock() {
        try {
            String lockNode = zooKeeper.create(rootNode + "/" + lockName, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
            List<String> nodes = zooKeeper.getChildren(rootNode, false);
            Collections.sort(nodes);
            if (lockNode.equals(rootNode + "/" + nodes.get(0))) {
                // 如果创建的节点是最小的节点，则表示获取到了锁
                lockPath = lockNode;
                return;
            }
            String currentNode = lockNode.substring(lockNode.lastIndexOf("/") + 1);
            // 获取比当前节点小的最大节点，并设置监听
            String preNode = nodes.get(Collections.binarySearch(nodes, currentNode) - 1);
            zooKeeper.exists(rootNode + "/" + preNode, new LockWatcher());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void unlock() {
        try {
            zooKeeper.delete(lockPath, -1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getState() == Event.KeeperState.SyncConnected) {
            countDownLatch.countDown();
        }
    }

    private class LockWatcher implements Watcher {
        @Override
        public void process(WatchedEvent event) {
            if (event.getType() == Event.EventType.NodeDeleted) {
                lock();
            }
        }
    }

    // 示例用法
    public static void main(String[] args) {
        String host = "localhost:2181";
        int sessionTimeout = 5000;
        String lockName = "mylock";

        try {
            ZooKeeperDistributedLock lock = new ZooKeeperDistributedLock(host, sessionTimeout, lockName);

            lock.lock();
            System.out.println("获取锁成功，执行业务逻辑...");
            // 执行业务逻辑

            lock.unlock();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 这个示例代码创建了一个 ZooKeeperDistributedLock 类，它封装了 ZooKeeper 的连接和操作方法，并提供了获取锁和释放锁的功能。在 lock 方法中，创建了一个临时顺序节点，并获取了父节点下的所有子节点，并对这些子节点进行排序。如果当前创建的节点是最小的节点，则表示获取到了锁；否则，设置对比当前节点小的最大节点的监听器，当该节点被删除时重新尝试获取锁。

需要注意的是，该示例中创建的节点是临时顺序节点，当客户端与 ZooKeeper 断开连接时，该节点会自动删除，从而释放锁。