zookeeper实现分布式锁

zookeeper提供了分布式环境下的一致性解决方案。借此我们可以实现分布式锁，而zookeeper实现的分布式锁可以有两种形式

1.分布式公平锁

公平锁就是指按照申请的顺序来发放锁，按照申请顺序分为1,2,3,4执行顺序也是1,2,3,4

我们可以利用zookeeper的临时顺序节点来实现分布式公平锁，顺序节点来实现公平锁，顺序节点会在节点id的最后维护一个值来保证顺序，

如果一个服务抢到锁后宕机没有释放锁那么就会陷入死锁，导致服务停摆，

redis实现分布式防止这种情况的方法是设置过期时间，并通过看门狗进行无限续期，如果服务宕机，看门狗不能续期，该记录就失效，失效后锁释放。

zookeeper的方法是使用临时节点，临时节点在服务与zookeeper结束会话时接自动删除。此时锁自动释放。

当一个服务想获取锁时，新建一个节点，如果自身不是顺序最小的那个节点就监听自己的前一个节点（序号比自己小1的）。如果前一个节点被删除了，就获得锁。

package org.example;

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

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

public class DistributedLock {
    private static final String ZOOKEEPER_CONNECTION_STRING = "localhost:2181";
    private static final int SESSION_TIMEOUT = 5000;
    private static final String LOCK_ROOT = "/locks";
    private static final String LOCK_NAME = "lock-";

    private ZooKeeper zooKeeper;
    private String lockPath;
    private String currentLock;

    public DistributedLock() throws IOException, InterruptedException, KeeperException {
        this.zooKeeper = new ZooKeeper(ZOOKEEPER_CONNECTION_STRING, SESSION_TIMEOUT, null);
        ensureRootPath();
    }

    private void ensureRootPath() throws KeeperException, InterruptedException {
        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 lock() throws KeeperException, InterruptedException {
        currentLock = zooKeeper.create(LOCK_ROOT + "/" + LOCK_NAME, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
        while (true) {
            List<String> children = zooKeeper.getChildren(LOCK_ROOT, false);
            Collections.sort(children);
            int index = children.indexOf(currentLock.substring(LOCK_ROOT.length() + 1));
            if (index == 0) {
                return;
            } else {
                String prevLock = LOCK_ROOT + "/" + children.get(index - 1);
                final CountDownLatch latch = new CountDownLatch(1);
                zooKeeper.exists(prevLock, new Watcher() {
                    @Override
                    public void process(WatchedEvent event) {
                        if (event.getType() == Event.EventType.NodeDeleted) {
                            latch.countDown();
                        }
                    }
                });
                latch.await();
            }
        }
    }

    public void unlock() throws KeeperException, InterruptedException {
        zooKeeper.delete(currentLock, -1);
    }

    public void close() throws InterruptedException {
        zooKeeper.close();
    }

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        DistributedLock distributedLock = new DistributedLock();
        distributedLock.lock();
        System.out.println("抢到锁了");
        // 执行临界区代码
        distributedLock.unlock();
        System.out.println();
        distributedLock.close();
    }
}

仍然可能出现死锁，同一个客户端多次拥有锁可能出现死锁。如果需要实现分布式锁可以使用Curator框架的InterProcessMutex。他自己维护了一个lockData来确保锁的可重入，解锁死锁。

2.分布式非公平锁

非公平锁指抢锁不按照顺序，一直抢谁运气好就谁拿下。多个服务一起创建节点，谁创建成功谁拥有锁，非顺序节点不允许同名，所以只有一个服务可以拥有锁。其他服务监听该节点，该节点被删除即锁被释放时，其余服务再一起争抢锁。

package org.example;

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;
import org.apache.zookeeper.ZooKeeper;

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

public class Main {
    public static final int NUM = 1;
    private static final String ZK_ADDRESS = "127.0.0.1:2181";
    private static final String LOCK_PATH = "/lock";

    public static void main(String[] args) throws IOException, InterruptedException, KeeperException {
        ZooKeeper zooKeeper = new ZooKeeper(ZK_ADDRESS, 1000, null);
        while (true) {

            if (lock(zooKeeper)) {
                System.out.println(NUM + "号抢锁成功");
                Thread.sleep(100);
                unlock(zooKeeper);
            } else {
                System.out.println(NUM + "号抢锁失败");

            }
        }
    }

    public static boolean lock(ZooKeeper zooKeeper) throws InterruptedException, KeeperException {
        try {
            zooKeeper.create(LOCK_PATH, String.valueOf(NUM).getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
            return true;

        } catch (KeeperException.NodeExistsException e) {
            final CountDownLatch latch = new CountDownLatch(1);
            zooKeeper.exists(LOCK_PATH, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeDeleted) {
                        latch.countDown();
                    }
                }
            });
            latch.await();
            return lock(zooKeeper);
        }
    }

    public static void unlock(ZooKeeper zooKeeper) throws InterruptedException, KeeperException {
        zooKeeper.delete(LOCK_PATH, -1);
    }
}

同样仍可能出现死锁。