Chubby vs. ZooKeeper：分布式协调服务的巅峰对决

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

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

public class DistributedLockExample {
    private static final String ZOOKEEPER_CONNECT_STRING = "localhost:2181";
    private static final int SESSION_TIMEOUT = 5000;
    private static final String LOCK_PATH = "/mylock";
    private static ZooKeeper zooKeeper;
    private static CountDownLatch connectedSignal = new CountDownLatch(1);

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        zooKeeper = new ZooKeeper(ZOOKEEPER_CONNECT_STRING, SESSION_TIMEOUT, new Watcher() {
            public void process(WatchedEvent event) {
                if (event.getState() == Event.KeeperState.SyncConnected) {
                    connectedSignal.countDown();
                }
            }
        });

        connectedSignal.await();

        createLockNode();

        // Acquire the lock
        if (acquireLock()) {
            System.out.println("Lock acquired. Do your work here.");
            // Simulate some work
            Thread.sleep(5000);
            releaseLock();
            System.out.println("Lock released.");
        } else {
            System.out.println("Failed to acquire lock.");
        }

        zooKeeper.close();
    }

    private static void createLockNode() throws KeeperException, InterruptedException {
        Stat stat = zooKeeper.exists(LOCK_PATH, false);
        if (stat == null) {
            zooKeeper.create(LOCK_PATH, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
        }
    }

    private static boolean acquireLock() throws KeeperException, InterruptedException {
        String lockPath = zooKeeper.create(LOCK_PATH + "/lock-", new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);

        while (true) {
            String[] nodes = zooKeeper.getChildren(LOCK_PATH, false).toArray(new String[0]);
            String smallestNode = findSmallestNode(nodes);
            if (lockPath.endsWith(smallestNode)) {
                return true; // Lock acquired
            }

            String previousNode = findPreviousNode(nodes, lockPath);
            if (previousNode != null) {
                final CountDownLatch latch = new CountDownLatch(1);
                final String pathToWatch = LOCK_PATH + "/" + previousNode;

                Stat stat = zooKeeper.exists(pathToWatch, new Watcher() {
                    public void process(WatchedEvent event) {
                        if (event.getType() == Event.EventType.NodeDeleted) {
                            latch.countDown();
                        }
                    }
                });

                if (stat != null) {
                    latch.await();
                }
            }
        }
    }

    private static void releaseLock() throws KeeperException, InterruptedException {
        zooKeeper.delete(LOCK_PATH, -1);
    }

    private static String findSmallestNode(String[] nodes) {
        String smallestNode = nodes[0];
        for (String node : nodes) {
            if (node.compareTo(smallestNode) < 0) {
                smallestNode = node;
            }
        }
        return smallestNode;
    }

    private static String findPreviousNode(String[] nodes, String current) {
        String previousNode = null;
        for (String node : nodes) {
            if (node.compareTo(current.substring(current.lastIndexOf("/") + 1)) == 0) {
                return previousNode;
            }
            previousNode = node;
        }
        return null;
    }
}