基于官方zookeeper的分布式锁实例的改动

有兴趣可以了解下这款国内人气很旺的JAVA代码生成器基于拖拽,不用写复杂的模板，支持多种数据库，适配wap,管理后台各种功能全有 免费开源 地址：https://blog.csdn.net/adyuebanwan/article/details/83006405 或者 http://www.magicalcoder.com

=======================================================================================

最近学习zookeeper,知道zookeeper可以实现分布式锁，具体算法就不赘述了，

把zookeeper官方提供的lock实例下载下来 ，发现 运行后的结果并不是自己想要的那样

 

我需要的场景：多台服务器 竞争锁，当没有得到锁的时候，会一直去请求锁，如果一台机器得到锁，那么在他没有释放锁之前，其他服务器无法获取锁

 

对源码进行了一小部分的改动 讲给懂得人听

1 测试类 Test

 

public static void main(String[] args) {
        for(int i=1;i<=4;i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        ZooKeeper zk = new ZooKeeper(Constant.SERVERLIST,5000 , new Watcher() {
                            @Override
                            //当对目录节点监控状态打开时，一旦目录节点的状态发生变化，Watcher 对象的 process 方法就会被调用。
                            public void process(WatchedEvent event) {
                                System.out.println("触发 event :"+ event.getType() );
                            }
                        });
                        WriteLock writeLock = new WriteLock(zk,"/lock/PROJECT1",null);
                        //尝试获取锁
                        if(writeLock.getLockUntilGetOne()){
                            System.out.println(zk.getSessionId()+"我获得了锁");
                            writeLock.unlock();
                            System.out.println(zk.getSessionId()+"我释放了锁");
                        }
                        zk.close();//一定要关闭zookeeper
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

2 ZNodeName 改动

 

 

public int compareTo(ZNodeName that) {
    //FIFO 先到先得策略
    //因为sequence是递增的，必须比较它，而不是比较prefix  prefix只是字符串，必须保证后面递增的要大于先前创建过的节点
        int s1 = this.sequence;
        int s2 = that.sequence;
        return s1 == -1 ? 1 : s2 == -1 ? -1 : s1 - s2;
        /*
        //老的逻辑 不对无法保证锁全局唯一
        int answer = this.prefix.compareTo(that.prefix);
        if (answer == 0) {
            int s1 = this.sequence;
            int s2 = that.sequence;
            if (s1 == -1 && s2 == -1) {
                return this.name.compareTo(that.name);
            }
            answer = s1 == -1 ? 1 : s2 == -1 ? -1 : s1 - s2;
        }
        return answer;*/
    }

3 WriteLock

 

  

    private class LockWatcher implements Watcher {
        public void process(WatchedEvent event) {
            // lets either become the leader or watch the new/updated node
            LOG.debug("Watcher fired on path: " + event.getPath() + " state: " +
                    event.getState() + " type " + event.getType());
            try {
                //这里就是循环获取锁 下面的lock没必要
                // lock();
            } catch (Exception e) {
                LOG.warn("Failed to acquire lock: " + e, e);
            }
        }
    }

 

 

 

</pre><pre>

 

    提供一个新方法

 

    /**
     * 循环获取锁 直到获取1个锁为止
     * @return
     * @throws KeeperException
     * @throws InterruptedException
     */
    public boolean getLockUntilGetOne() throws KeeperException, InterruptedException {
        while (!lock()){}
        return true;
    }