zookeeper实现分布式读写锁

package com.shenyuchong.zkclient;
import com.gbd.database.Cache;
import org.apache.log4j.Logger;
import org.apache.zookeeper.CreateMode;
import org.apache.zookeeper.ZooDefs;
import org.apache.zookeeper.ZooKeeper;
import java.util.List;
import java.util.Random;

public class ZkClient {
    private static Logger log = Logger.getLogger(ZkClient.class);
    private final static String LOCK_HOME="/shenyuchong";//分布式锁的工作目录
    private static Object lock = new Object();
    private static ZooKeeper zooKeeper =  null;
    public static void init() throws Exception {
        /**
         * 一开始就与Zookeeper服务器连接上
         */
        zooKeeper = new ZooKeeper(Cache.ZOOKEEPER_CONNECT_STRING, 5000, null);
        if(zooKeeper!=null){
            if(zooKeeper.exists(LOCK_HOME, false)==null){
                zooKeeper.create(LOCK_HOME,null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
            }
        }
    }
    public static Sequent readLock(String path){
        path=LOCK_HOME+(path.startsWith("/")?path:"/"+path);//传入目录不是/开头的添加一个斜杠
        String seq = null;
        try {
            createPath(zooKeeper,path);//防止目录不存在先创建(同步)
            boolean hasWrite=true;//是否存在写锁
            while(hasWrite){
                hasWrite=false;
                /**
                 * 在path目录下先创建一个读r_开头的顺序型临时节点，然后再判断该目录下的孩子中是否有写节点(w_开头的节点)
                 */
                seq = zooKeeper.create(path + "/r_", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                List<String> children = zooKeeper.getChildren(path, false);
                for(String c:children){
                    if(c.startsWith("w_")) {
                        hasWrite=true;
                        break;
                    }
                }
                if(hasWrite){
                    /**
                     * 当发现有写线程，则删除刚才创建的读节点，并阻塞当前线程，等待通知或者等待一个随机时间
                     */                    zooKeeper.delete(seq,-1);
                    synchronized (lock) {
                        /**
                         * 随机时间不能小于3秒，因为我们认为写任务一搬没这么快完成
                         */
                        Random rand =new Random();
                        int i = rand.nextInt(10000);
                        if(i<3000) i=3000;
                        lock.wait(i);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new Sequent(seq);
    }
    public static Sequent writeLock(String path){
        path=LOCK_HOME+(path.startsWith("/")?path:"/"+path);
        String seq = null;
        try {
            createPath(zooKeeper,path);
            boolean hasRead=true;
            while(hasRead){
                /**
                 * 在path目录下先创建一个写w_开头的顺序型临时节点，然后再判断该目录下的孩子中是否有节点(不管是写线程还是读线程都应该等待)
                 */
                seq = zooKeeper.create(path + "/w_", null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL_SEQUENTIAL);
                List<String> children = zooKeeper.getChildren(path, false);
                if(children!=null&&children.size()>1){
/**
                     * 当发现有写线程，则删除刚才创建的读节点，并阻塞当前线程，等待通知或者等待一个随机时间
                     */
                    zooKeeper.delete(seq,-1);
                    hasRead=true;
                    synchronized (lock) {
                        Random rand =new Random();
                        /**
                         * 随机时间不能小于1秒，因为我们认为读线程应该进可能的响应
                         */
                        int i = rand.nextInt(10000);
                        if(i<1000) i=1000;
                        lock.wait(i);
                    }
                }else{
                    hasRead=false;
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return new Sequent(seq);
    }
    public static void unLock(Sequent sequent){
        if(sequent==null||sequent.getName()==null||"".equals(sequent.getName())) return;
        try {
            /**
             * 删除又线程创建的节点就代表解锁了，最后需要通知所有线程，分布式的程序通知不了，所以需要在wait()中传入等待的时间参数
             */
            zooKeeper.delete(sequent.getName(),-1);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            synchronized (lock){
                lock.notifyAll();//通知的话可以减少等待时间
            }
        }
    }
    public static void createPath(ZooKeeper zooKeeper,String path){
        try {
            if(zooKeeper.exists(path, false)==null)
                zooKeeper.create(path,null, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);//创建一个持久化节点
        }catch (Exception e){
            e.printStackTrace();
        }
    }
　　//节点名称（用于给解锁用，单一个字符串约束性低）
    public static class Sequent{
        private String name;
        public Sequent(String name) {
            this.name = name;
        }
        public String getName() {
            return name;
        }
    }
}