zookeeper实现分布式锁

分布式锁实现原理：
zookeeper有一个有序节点的特性，通过这一特性。
首先保证每个每一个客户端都能到zookeeper上注册一个节点，但是要获得锁的话，从这个节点下所有子节点中获得一个id最小的一个子节点，表示当前这个子节点能获得这个锁。
其他比它id大的子节点，每个节点通过去监听比他小一个的节点，例如/lock_seq2去监听/lock_seq1,/lock_seq3去监听/lock_seq2,当比他小的那个节点（lock_seq1）发生变化之后，它（lock_seq2）会收到一个事件，再去判断当前节点（lock_seq2）是不是目前队列中，节点最小的，如果是，将获得锁，如果不是继续等待。

1.创建锁

package com.example.demo.zooker;

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

import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.List;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Distributedlock implements Lock, Watcher {
    private ZooKeeper zk = null;
    private String ROOT_LOCK="/locks";//定义根节点
    private String WAIT_LOCK;//等待前一个锁
    private String CURRENT_LOCK;//表示当前锁
    private CountDownLatch countDownLatch;//

    public Distributedlock() {
        try {
            zk = new ZooKeeper("192.168.0.128:2181",
                    50000,this);
            Stat stat = zk.exists(ROOT_LOCK,false);
            if (stat==null){
                /**
                 1.ZooDefs.Ids
                 * OPEN_ACL_UNSAFE  : 完全开放的ACL，任何连接的客户端都可以操作该属性znode
                 * CREATOR_ALL_ACL : 只有创建者才有ACL权限
                 * READ_ACL_UNSAFE：只能读取ACL
                 2.CreateMode
                PERSISTENT  持久化目录节点，存储的数据不会丢失。
                PERSISTENT_SEQUENTIAL   顺序自动编号的持久化目录节点，存储的数据不会丢失，并且根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名。
                EPHEMERAL           临时目录节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除。
                 EPHEMERAL_SEQUENTIAL   临时自动编号节点，一旦创建这个节点的客户端与服务器端口也就是session 超时，这种节点会被自动删除，并且根据当前已近存在的节点数自动加 1，然后返回给客户端已经成功创建的目录节点名。
                 **/
                zk.create(ROOT_LOCK,"0".getBytes(),
                        ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void lock() {
        if (this.tryLock()){
            //如果获得锁成功
            System.out.println(Thread.currentThread().getName()+"->"+CURRENT_LOCK+"->获得锁成功");
            return;
        }
        try {
            //没有获得锁，继续等待
            waitForLock(WAIT_LOCK);
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private boolean waitForLock(String prev) throws KeeperException, InterruptedException {
        //监听当前节点的上一个节点
        Stat stat = zk.exists(prev,true);
        //如果上个锁没了，唤醒队列，重新获得锁
        if (stat!=null){
            System.out.println(Thread.currentThread().getName()
                    +"->等待锁"+ROOT_LOCK+"/"+prev+"释放");
            countDownLatch  = new CountDownLatch(1);
            countDownLatch.await();
            System.out.println(Thread.currentThread().getName()+"->获得锁成功");
        }
        return true;
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }

    @Override
    public boolean tryLock() {
        try {
            //创建临时有序节点
            CURRENT_LOCK=zk.create(ROOT_LOCK+"/", "0".getBytes(),
                    ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
            System.out.println(Thread.currentThread().getName()+"->"+CURRENT_LOCK
                    +",尝试竞争锁");
            //获取根节点下的所有子节点
            List<String> childrens = zk.getChildren(ROOT_LOCK,false);
            //定义一个有序集合
            SortedSet<String> sortedSet =new TreeSet();
            for (String children:childrens){
                sortedSet.add(ROOT_LOCK+"/"+children);
            }
            //获取当前所有子节点中最小的节点
            String firstNode = sortedSet.first();
            SortedSet<String> lessThenMe = ((TreeSet<String>) sortedSet)
                    .headSet(CURRENT_LOCK);
            //通过当前的节点和子节点中最小的节点比较，如果相等，获得锁成功
            if (CURRENT_LOCK.equals(firstNode)){
                return true;
            }
            if (!lessThenMe.isEmpty()){
                //获得比当前节点更小的最后一个节点，设置给WAIT_LOCK
                WAIT_LOCK=lessThenMe.last();
            }
        } catch (KeeperException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }

    @Override
    public void unlock() {
        System.out.println(Thread.currentThread().getName()+"->释放锁"+CURRENT_LOCK);
        try {
            zk.delete(CURRENT_LOCK,-1);
            CURRENT_LOCK=null;
            zk.close();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (KeeperException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Condition newCondition() {
        return null;
    }

    @Override
    public void process(WatchedEvent watchedEvent) {
        if (this.countDownLatch!=null){
            this.countDownLatch.countDown();
        }
    }
}

2.调用锁

package com.example.demo.zooker;

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

public class App {
    public static void main(String[] args) throws IOException {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i=0;i<10;i++){
            new Thread(()->{
                try {
                    countDownLatch.await();
                    Distributedlock distributedlock = new Distributedlock();
                    distributedlock.lock();//获得锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },"Thread-"+i
            ).start();
            countDownLatch.countDown();
        }
        System.in.read();
    }
}