当前位置：首页 > article >正文

Zookeeper（58）如何在Zookeeper中实现分布式锁？

article 2025/2/22 22:05:52

在 Zookeeper 中实现分布式锁是一种常见的用例。Zookeeper 提供了强一致性、高可用性的分布式协调服务，使得它非常适合用来实现分布式锁。以下是详细的步骤和代码示例，展示如何在 Zookeeper 中实现分布式锁。

1. Zookeeper 分布式锁的基本原理

Zookeeper 分布式锁的实现主要依赖于以下几点：

临时顺序节点：每个客户端在尝试获取锁时，会在特定节点下创建一个临时顺序节点。
节点排序：所有客户端创建的节点会按顺序排列，最小的节点获得锁。
监视前一个节点：每个客户端监视它前一个节点的变化，当前一个节点被删除时，当前客户端重新检查自己是否是最小的节点，如果是，则获得锁。

2. 添加依赖

首先，需要在项目中添加 Zookeeper 的依赖。以下是 Maven 和 Gradle 的依赖配置：

Maven

在 pom.xml 中添加 Zookeeper 依赖：

<dependency>
    <groupId>org.apache.zookeeper</groupId>
    <artifactId>zookeeper</artifactId>
    <version>3.7.0</version>
</dependency>

Gradle

在 build.gradle 中添加 Zookeeper 依赖：

dependencies {
    implementation 'org.apache.zookeeper:zookeeper:3.7.0'
}

3. 实现分布式锁

以下是一个完整的实现分布式锁的示例代码。

ZookeeperClient.java

import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

public class ZookeeperClient {
    private static final String ZK_ADDRESS = "localhost:2181";
    private static final int SESSION_TIMEOUT = 3000;
    private ZooKeeper zooKeeper;

    public void connect() throws Exception {
        zooKeeper = new ZooKeeper(ZK_ADDRESS, SESSION_TIMEOUT, new Watcher() {
            @Override
            public void process(WatchedEvent event) {
                System.out.println("Received event: " + event);
            }
        });
    }

    public void close() throws InterruptedException {
        if (zooKeeper != null) {
            zooKeeper.close();
        }
    }

    public ZooKeeper getZooKeeper() {
        return zooKeeper;
    }

    public static void main(String[] args) {
        ZookeeperClient client = new ZookeeperClient();
        try {
            client.connect();
            // 在这里可以测试分布式锁
            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

DistributedLock.java

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;

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

public class DistributedLock {
    private static final String LOCK_ROOT = "/locks";
    private static final String LOCK_NODE = LOCK_ROOT + "/lock_";
    private ZooKeeper zooKeeper;
    private String lockPath;

    public DistributedLock(ZooKeeper zooKeeper) throws Exception {
        this.zooKeeper = zooKeeper;
        Stat stat = zooKeeper.exists(LOCK_ROOT, false);
        if (stat == null) {
            zooKeeper.create(LOCK_ROOT, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    public void acquireLock() throws Exception {
        lockPath = zooKeeper.create(LOCK_NODE, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println("Lock path: " + lockPath);

        while (true) {
            List<String> children = zooKeeper.getChildren(LOCK_ROOT, false);
            Collections.sort(children);
            String smallestChild = LOCK_ROOT + "/" + children.get(0);

            if (lockPath.equals(smallestChild)) {
                System.out.println("Acquired lock: " + lockPath);
                return;
            }

            String watchNode = null;
            for (int i = children.size() - 1; i >= 0; i--) {
                String child = LOCK_ROOT + "/" + children.get(i);
                if (child.compareTo(lockPath) < 0) {
                    watchNode = child;
                    break;
                }
            }

            if (watchNode != null) {
                final Object lock = new Object();
                Watcher watcher = new Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        synchronized (lock) {
                            lock.notifyAll();
                        }
                    }
                };

                Stat stat = zooKeeper.exists(watchNode, watcher);
                if (stat != null) {
                    synchronized (lock) {
                        lock.wait();
                    }
                }
            }
        }
    }

    public void releaseLock() throws Exception {
        if (lockPath != null) {
            zooKeeper.delete(lockPath, -1);
            System.out.println("Released lock: " + lockPath);
            lockPath = null;
        }
    }

    public static void main(String[] args) {
        ZookeeperClient client = new ZookeeperClient();
        try {
            client.connect();
            ZooKeeper zooKeeper = client.getZooKeeper();

            DistributedLock lock = new DistributedLock(zooKeeper);
            lock.acquireLock();

            // 模拟业务逻辑
            Thread.sleep(5000);

            lock.releaseLock();
            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 代码说明

ZookeeperClient 类

ZookeeperClient 类负责连接和关闭 Zookeeper 客户端，并提供获取 ZooKeeper 实例的方法。

DistributedLock 类

DistributedLock 类负责实现分布式锁的逻辑，包括获取锁和释放锁。

acquireLock() 方法：尝试获取锁，创建临时顺序节点，然后检查自己是否是最小的节点。如果是，则获得锁；否则，监视前一个节点的变化。
releaseLock() 方法：释放锁，删除自己创建的临时顺序节点。

5. 测试分布式锁

在 DistributedLock 类的 main 方法中，创建 ZookeeperClient 实例并连接 Zookeeper，然后创建 DistributedLock 实例并尝试获取和释放锁。可以通过运行多个实例来测试分布式锁的功能。

public static void main(String[] args) {
    ZookeeperClient client = new ZookeeperClient();
    try {
        client.connect();
        ZooKeeper zooKeeper = client.getZooKeeper();

        DistributedLock lock = new DistributedLock(zooKeeper);
        lock.acquireLock();

        // 模拟业务逻辑
        Thread.sleep(5000);

        lock.releaseLock();
        client.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}