org.apache.zookeeper.createmode

org.apache.zookeeper.createmode是ZooKeeper API中的一个枚举类，用于指定创建ZooKeeper节点时的创建模式。该枚举类包含4个枚举值：

- PERSISTENT：持久化节点
- PERSISTENT_SEQUENTIAL：持久化顺序节点
- EPHEMERAL：临时节点
- EPHEMERAL_SEQUENTIAL：临时顺序节点

其中，持久化节点会一直存在于ZooKeeper集群中，直到被显式删除；临时节点则只有在创建该节点的客户端与ZooKeeper集群连接断开时才会被自动删除。顺序节点则会在节点名称后面追加一个单调递增的数字，用于保证节点的创建顺序。

相关问题

zookeeper创建节点

在ZooKeeper中创建节点可以使用ZooKeeper的客户端API或者命令行工具来完成。以下是使用客户端API创建节点的示例代码：

import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import java.io.IOException;

public class ZKCreateNode implements Watcher {

    private static ZooKeeper zooKeeper;

    public static void main(String[] args) throws Exception {
        // 连接ZooKeeper服务器
        zooKeeper = new ZooKeeper("localhost:2181", 5000, new ZKCreateNode());

        // 创建一个节点
        String path = "/test";
        byte[] data = "hello world".getBytes();
        zooKeeper.create(path, data, Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
    }

    @Override
    public void process(WatchedEvent event) {
        // 处理事件
    }
}

在上述代码中，我们首先连接到ZooKeeper服务器，然后通过`create`方法创建了一个名为`/test`的节点，并将`hello world`作为节点的数据写入其中。`Ids.OPEN_ACL_UNSAFE`表示节点的访问权限为完全开放，`CreateMode.PERSISTENT`表示节点是持久化节点。如果要创建临时节点，可以使用`CreateMode.EPHEMERAL`。

在命令行工具中，可以使用`create`命令来创建节点，例如：

create /test hello

这个命令会在根节点下创建一个名为`test`的节点，并将`hello`作为节点的数据写入其中。如果需要创建持久化节点，可以在命令中添加`-p`选项，例如：

create -p /path/to/node

这个命令会递归创建`/path/to/node`路径上的所有节点，并将`node`节点设置为持久化节点。

java zookeeper分布式锁demo

以下是一个基于 ZooKeeper 实现分布式锁的 Java Demo：

import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooDefs.Ids;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;

public class DistributedLock implements Watcher {

    private static final String ZK_ADDRESS = "localhost:2181";
    private static final int SESSION_TIMEOUT = 5000;
    private static final String LOCK_ROOT = "/locks";
    private static final String LOCK_PREFIX = "lock_";
    private String lockPath;
    private ZooKeeper zk;
    private CountDownLatch connectedSignal = new CountDownLatch(1);
    private CountDownLatch lockSignal = new CountDownLatch(1);

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

    public boolean lock() throws Exception {
        lockPath = zk.create(LOCK_ROOT + "/" + LOCK_PREFIX, new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        while (true) {
            String prevLock = getPrevLock();
            if (prevLock == null) {
                return true;
            } else {
                zk.exists(prevLock, true);
                lockSignal.await();
            }
        }
    }

    public void unlock() throws Exception {
        zk.delete(lockPath, -1);
    }

    private String getPrevLock() throws KeeperException, InterruptedException {
        String prevLock = null;
        String[] nodes = zk.getChildren(LOCK_ROOT, false).toArray(new String[0]);
        for (int i = 0; i < nodes.length; i++) {
            if (lockPath.endsWith(nodes[i])) {
                if (i > 0) {
                    prevLock = LOCK_ROOT + "/" + nodes[i - 1];
                }
                break;
            }
        }
        return prevLock;
    }

    @Override
    public void process(WatchedEvent event) {
        if (event.getState() == Event.KeeperState.SyncConnected) {
            connectedSignal.countDown();
        } else if (event.getType() == Event.EventType.NodeDeleted && event.getPath().equals(getPrevLock())) {
            lockSignal.countDown();
        }
    }

}

这个 Demo 中，`DistributedLock` 类实现了分布式锁的基本操作。使用时，首先需要创建一个 `DistributedLock` 对象，然后调用 `lock` 方法获取锁，调用 `unlock` 方法释放锁。

这个 Demo 中使用 ZooKeeper 的 `EPHEMERAL_SEQUENTIAL` 模式创建了一个临时顺序节点，如果当前节点是序号最小的节点，则获取到锁。如果不是，则在当前节点的前一个节点上注册一个 Watcher，当前一个节点被删除时，当前节点就可以获取到锁了。

需要注意的是，这个 Demo 中的锁并没有考虑超时问题。在实际使用中，需要根据具体情况进行优化。