Zookeeper实现分布式锁（javaAPI）

Zookeeper实现分布式锁（javaAPI）

最近学习了zookeeper，发现zookeeper还是很强大的，能做的事情很多，比如数据的发布/订阅、master选举、分布式队列、分布式锁等等，我自己是在win10装了个虚拟机，然后在上面跑zookeeper（版本是3.4.12，这里的版本是虚拟机上的版本，不是pom的版本）。
使用zookeeper其实有三种方式：javaAPI、zkClient、curator，我这里使用的是javaAPI，其实使用后我个人觉得curator封装的更好，不过这里就不贴代码了，先用javaAPI来实现，因为其他两种都是基于这个去做封装的，所以最麻烦的如果都懂了，换种形式的理解起来也就不难了~

• 开发环境
  
  • jdk1.8、springboot、STS

---

添加的依赖

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

添加完如果快捷提示没有出现对应的类记得install和update一下啊

代码块

DistributeLock.java：

import java.io.IOException;
import java.util.List;
import java.util.Random;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;

public class DistributeLock {
    //根节点
    private static final String ROOT_LOCKS="/LOCKS";

    private ZooKeeper zooKeeper;
    //回话超时时间
    private int sessionTimeout;
    //记录锁节点ID
    private String lockID;
    //保存的数据，这里我就随便写了1和2
    private final static byte[] data = {1,2};
    //计数器
    private CountDownLatch countDownLatch = new CountDownLatch(1);
    //构造方法
    public DistributeLock() throws IOException, InterruptedException {
        this.zooKeeper = ZookeeperClient.getInstance();
        this.sessionTimeout = ZookeeperClient.getSessionTimeout();
    }

    //获取锁的方法
    public boolean lock() throws KeeperException, InterruptedException {
        /**这里有地方是需要注意的，因为我们创建的是临时有序节
        点，所有获取节点的时候我们是认定为获取最小的一个并且获
        取成功则认为它获取到了锁，而创建节点的时候这里传的是
        ROOT_LOCK/，zookeeper在为我们创建节点是时候会帮我
        们生成这样的节点LOCKS/00000001，自动带上序号*/
        lockID = zooKeeper.create(ROOT_LOCKS + "/", data, ZooDefs.Ids.OPEN_ACL_UNSAFE, 
                CreateMode.EPHEMERAL_SEQUENTIAL);
        System.out.println(Thread.currentThread().getName() + 
                "-->成功创建了lock节点[" + lockID + "],开始去竞争锁");

        //获取根节点下的所有子节点
        List<String> childrenNodes = zooKeeper.getChildren(ROOT_LOCKS, true);
        //排序，从小到大
        SortedSet<String> sortedSet = new TreeSet<>();
        for(String c : childrenNodes) {
            sortedSet.add(ROOT_LOCKS + "/" + c);
        }
        String first = sortedSet.first();
        if(lockID.equals(first)) {
            //表示当前就是最小的节点
            System.out.println(Thread.currentThread().getName() + 
                    "-->成功获得锁，lock节点为：["+ lockID +"]");
            return true;
        }
        SortedSet<String> lessThenLockId = sortedSet.headSet(lockID);
        if(!lessThenLockId.isEmpty()) {
            //拿到比当前lockID这个节点更小的上一个节点
            String prevLockID = lessThenLockId.last();
            /**这个地方其实是去监听prevLockID，为什么要这样做呢，因为我当前的lockID不能
               成功获得锁，那其实也就意味着我这个节点下面的更不可能获得锁了，获得锁的只有可
               能是他往前的节点，所以去监听上一个节点
            */
            zooKeeper.exists(prevLockID, new LockWatcher(countDownLatch));
            /**
                传了一个计数器到watcher也就是监听，当我监听到了该节点做了删除操作或者它的会
                话超时了，那么这个时候计数器减1
            */
            countDownLatch.await(sessionTimeout, TimeUnit.MILLISECONDS);
            //上面这段代码意味着如果会话超时或者节点被删除了
            System.out.println(Thread.currentThread().getName() + 
                    "成功获取锁：[" + lockID + "]");
        }
        return true;
    }


    public boolean unlock() {

        System.out.println(Thread.currentThread().getName() + "-->开始释放锁["
                + lockID + "]");
        try {
            //这里delete的时候版本传的-1，意思是忽略版本的控制
            zooKeeper.delete(lockID, -1);
            System.out.println("节点[" + lockID + "]成功被删除");

        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (KeeperException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return false;
    }

    public static void main(String[] args) {
        Random random = new Random();
        CountDownLatch latch = new CountDownLatch(10);
        for(int i = 0; i < 10; i++) {
            new Thread(() -> {
                DistributeLock lock = null;

                try {
                    lock = new DistributeLock();
                    latch.countDown();
                    latch.await();
                    try {
                        lock.lock();
                    } catch (KeeperException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    Thread.sleep(random.nextInt(500));
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    if(lock != null) {
                        lock.unlock();
                    }
                }
            }).start();
        }





    }

}

LockWatcher.java(监听器的代码)：

import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.Watcher.Event.EventType;

public class LockWatcher implements Watcher {

    private CountDownLatch latch;
    //构造函数传了计数器进来
    public LockWatcher(CountDownLatch latch) {
        this.latch = latch;
    }

    @Override
    public void process(WatchedEvent event) {
        // TODO Auto-generated method stub
        //当事件类型为删除节点时，计数器减1
        if(event.getType() == EventType.NodeDeleted) {
            latch.countDown();
        }
    }
}

ZookeeperClient.java：

import java.io.IOException;
import java.util.concurrent.CountDownLatch;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

public class ZookeeperClient {
    //这里是我虚拟地的地址，只做了单机的，没做集群，如果是集群地址用逗号分隔开
    private final static String CONNECTIONSTRING = "192.168.1.100:2181";
    //会话超时时间
    private static int sessionTimeout = 5000;

    //获取连接
    public static ZooKeeper getInstance() throws IOException, InterruptedException {
        final CountDownLatch connectStatus = new CountDownLatch(1);
        ZooKeeper zooKeeper = new ZooKeeper(CONNECTIONSTRING, sessionTimeout, new Watcher() {

            @Override
            public void process(WatchedEvent event) {
                // TODO Auto-generated method stub
                //当状态为已连接的时候，计数器减1
                if(event.getState() == Event.KeeperState.SyncConnected) {
                    connectStatus.countDown();
                }
            }
        });
        connectStatus.await();
        return zooKeeper;
    }

    public static int getSessionTimeout() {
        return sessionTimeout;
    }
}

代码到这里就结束啦，其实要跑起来还是不麻烦的，主要是我觉得比较重要的地方是要明白为什么zookeeper为什么可以实现分布式锁，其实这跟他的数据模型有很大的关系（树形），而我们这里为什么使用的是临时有序节点，一是因为有序的，所以获取锁的原则是以获取到最小节点的判定为成功，二是因为会话关闭后节点不会一直存在于zookeeper当中。

如果大家发现有什么问题或者更好的意见欢迎交流啊~

---