zoukankan      html  css  js  c++  java
  • zk实现分布式锁

    1.获取分布式锁的总体思路

            在获取分布式锁的时候在locker节点下创建临时顺序节点,释放锁的时候删除该临时节点。客户端调用createNode方法在locker下创建临时顺序节点,

    然后调用getChildren(“locker”)来获取locker下面的所有子节点,注意此时不用设置任何Watcher。客户端获取到所有的子节点path之后,如果发现自己在之

    前创建的子节点序号最小,那么就认为该客户端获取到了锁。如果发现自己创建的节点并非locker所有子节点中最小的,说明自己还没有获取到锁,

    此时客户端需要找到比自己小的那个节点,然后对其调用exist()方法,同时对其注册事件监听器。之后,让这个被关注的节点删除,则客户端的Watcher会

    收到相应通知,此时再次判断自己创建的节点是否是locker子节点中序号最小的,如皋是则获取到了锁,如果不是则重复以上步骤继续获取到比自己小的一个

    节点并注册监听。当前这个过程中还需要许多的逻辑判断。

    2.获取分布式锁的核心算法流程

            下面同个一个流程图来分析获取分布式锁的完整算法,如下:

            

            解释:客户端A要获取分布式锁的时候首先到locker下创建一个临时顺序节点(node_n),然后立即获取locker下的所有(一级)子节点。

    此时因为会有多个客户端同一时间争取锁,因此locker下的子节点数量就会大于1。对于顺序节点,特点是节点名称后面自动有一个数字编号,

    先创建的节点数字编号小于后创建的,因此可以将子节点按照节点名称后缀的数字顺序从小到大排序,这样排在第一位的就是最先创建的顺序节点,

    此时它就代表了最先争取到锁的客户端!此时判断最小的这个节点是否为客户端A之前创建出来的node_n,如果是则表示客户端A获取到了锁,

    如果不是则表示锁已经被其它客户端获取,因此客户端A要等待它释放锁,也就是等待获取到锁的那个客户端B把自己创建的那个节点删除。

    此时就通过监听比node_n次小的那个顺序节点的删除事件来知道客户端B是否已经释放了锁,如果是,此时客户端A再次获取locker下的所有子节点,

    再次与自己创建的node_n节点对比,直到自己创建的node_n是locker的所有子节点中顺序号最小的,此时表示客户端A获取到了锁!

    客户端调用create()方法创建名为“locknode/guid-lock-”的节点,需要注意的是,这里节点的创建类型需要设置为EPHEMERAL_SEQUENTIAL。 
    客户端调用getChildren(“locknode”)方法来获取所有已经创建的子节点,同时在这个节点上注册上子节点变更通知的Watcher。 
    客户端获取到所有子节点path之后,如果发现自己在步骤1中创建的节点是所有节点中序号最小的,那么就认为这个客户端获得了锁。 
    如果在步骤3中发现自己并非是所有子节点中最小的,说明自己还没有获取到锁,就开始等待,直到下次子节点变更通知的时候,再进行子节点的获取,判断是否获取锁。 
    释放锁的过程相对比较简单,就是删除自己创建的那个子节点即可。

    问题所在

    上面这个分布式锁的实现中,大体能够满足了一般的分布式集群竞争锁的需求。这里说的一般性场景是指集群规模不大,一般在10台机器以内。

    不过,细想上面的实现逻辑,我们很容易会发现一个问题,步骤4,“即获取所有的子点,判断自己创建的节点是否已经是序号最小的节点”,这个过程,在整个分布式锁的竞争过程中,大量重复运行,并且绝大多数的运行结果都是判断出自己并非是序号最小的节点,从而继续等待下一次通知——这个显然看起来不怎么科学。客户端无端的接受到过多的和自己不相关的事件通知,这如果在集群规模大的时候,会对Server造成很大的性能影响,并且如果一旦同一时间有多个节点的客户端断开连接,这个时候,服务器就会像其余客户端发送大量的事件通知——这就是所谓的羊群效应。而这个问题的根源在于,没有找准客户端真正的关注点。

    我们再来回顾一下上面的分布式锁竞争过程,它的核心逻辑在于:判断自己是否是所有节点中序号最小的。于是,很容易可以联想的到的是,每个节点的创建者只需要关注比自己序号小的那个节点。

    改进后的分布式锁实现

    下面是改进后的分布式锁实现,和之前的实现方式唯一不同之处在于,这里设计成每个锁竞争者,只需要关注”locknode”节点下序号比自己小的那个节点是否存在即可。实现如下:

    客户端调用create()方法创建名为“locknode/guid-lock-”的节点,需要注意的是,这里节点的创建类型需要设置为EPHEMERAL_SEQUENTIAL。 
    客户端调用getChildren(“locknode”)方法来获取所有已经创建的子节点,注意,这里不注册任何Watcher。 
    客户端获取到所有子节点path之后,如果发现自己在步骤1中创建的节点序号最小,那么就认为这个客户端获得了锁。 
    如果在步骤3中发现自己并非所有子节点中最小的,说明自己还没有获取到锁。此时客户端需要找到比自己小的那个节点,然后对其调用exist()方法,同时注册事件监听。 
    之后当这个被关注的节点被移除了,客户端会收到相应的通知。这个时候客户端需要再次调用getChildren(“locknode”)方法来获取所有已经创建的子节点,确保自己确实是最小的节点了,然后进入步骤3。 
    结论

    上次两个分布锁实现,都是可行的。具体选择哪个,取决于你的集群规模。

    转发来自:http://rdc.taobao.com/team/jm/archives/tag/zookeeper

    基于ZooKeeper的分布式锁和队列

     

    在分布式系统中,往往需要一些分布式同步原语来做一些协同工作,上一篇文章介绍了Zookeeper的基本原理,本文介绍下基于Zookeeper的Lock和Queue的实现,主要代码都来自Zookeeper的官方recipe。

    锁(Lock)

    完全分布式锁是全局同步的,这意味着在任何时刻没有两个客户端会同时认为它们都拥有相同的锁,使用 Zookeeper 可以实现分布式锁,需要首先定义一个锁节点(lock root node)。

    需要获得锁的客户端按照以下步骤来获取锁:

    1. 保证锁节点(lock root node)这个父根节点的存在,这个节点是每个要获取lock客户端共用的,这个节点是PERSISTENT的。
    2. 第一次需要创建本客户端要获取lock的节点,调用 create( ),并设置 节点为EPHEMERAL_SEQUENTIAL类型,表示该节点为临时的和顺序的。如果获取锁的节点挂掉,则该节点自动失效,可以让其他节点获取锁。

    3. 在父锁节点(lock root node)上调用 getChildren( ) ,不需要设置监视标志。 (为了避免“羊群效应”).

    4. 按照Fair竞争的原则,将步骤3中的子节点(要获取锁的节点)按照节点顺序的大小做排序,取出编号最小的一个节点做为lock的owner,判断自己的节点id
      是否就为owner id,如果是则返回,lock成功。如果不是则调用 exists( )监听比自己小的前一位的id,关注它锁释放的操作(也就是exist watch)。

    5. 如果第4步监听exist的watch被触发,则继续按4中的原则判断自己是否能获取到lock。

    释放锁:需要释放锁的客户端只需要删除在第2步中创建的节点即可。

    注意事项:

    一个节点的删除只会导致一个客户端被唤醒,因为每个节点只被一个客户端watch,这避免了“羊群效应”。

    一个分布式lock的实现:

    复制代码
    package org.apache.zookeeper.recipes.lock;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.apache.zookeeper.KeeperException;
    import org.apache.zookeeper.WatchedEvent;
    import org.apache.zookeeper.Watcher;
    import static org.apache.zookeeper.CreateMode.EPHEMERAL_SEQUENTIAL;
    import org.apache.zookeeper.ZooKeeper;
    import org.apache.zookeeper.data.ACL;
    import org.apache.zookeeper.data.Stat;
    
    import java.util.List;
    import java.util.SortedSet;
    import java.util.TreeSet;
    
    /**
     * A <a href="package.html">protocol to implement an exclusive
     *  write lock or to elect a leader</a>. <p/> You invoke {@link #lock()} to 
     *  start the process of grabbing the lock; you may get the lock then or it may be 
     *  some time later. <p/> You can register a listener so that you are invoked 
     *  when you get the lock; otherwise you can ask if you have the lock
     *  by calling {@link #isOwner()}
     *
     */
    public class WriteLock extends ProtocolSupport {
        private static final Logger LOG = LoggerFactory.getLogger(WriteLock.class);
    
        private final String dir;
        private String id;
        private ZNodeName idName;
        private String ownerId;
        private String lastChildId;
        private byte[] data = {0x12, 0x34};
        private LockListener callback;
        private LockZooKeeperOperation zop;
        
        /**
         * zookeeper contructor for writelock
         * @param zookeeper zookeeper client instance
         * @param dir the parent path you want to use for locking
         * @param acls the acls that you want to use for all the paths, 
         * if null world read/write is used.
         */
        public WriteLock(ZooKeeper zookeeper, String dir, List<ACL> acl) {
            super(zookeeper);
            this.dir = dir;
            if (acl != null) {
                setAcl(acl);
            }
            this.zop = new LockZooKeeperOperation();
        }
        
        /**
         * zookeeper contructor for writelock with callback
         * @param zookeeper the zookeeper client instance
         * @param dir the parent path you want to use for locking
         * @param acl the acls that you want to use for all the paths
         * @param callback the call back instance
         */
        public WriteLock(ZooKeeper zookeeper, String dir, List<ACL> acl, 
                LockListener callback) {
            this(zookeeper, dir, acl);
            this.callback = callback;
        }
    
        /**
         * return the current locklistener
         * @return the locklistener
         */
        public LockListener getLockListener() {
            return this.callback;
        }
        
        /**
         * register a different call back listener
         * @param callback the call back instance
         */
        public void setLockListener(LockListener callback) {
            this.callback = callback;
        }
    
        /**
         * Removes the lock or associated znode if 
         * you no longer require the lock. this also 
         * removes your request in the queue for locking
         * in case you do not already hold the lock.
         * @throws RuntimeException throws a runtime exception
         * if it cannot connect to zookeeper.
         */
        public synchronized void unlock() throws RuntimeException {
            
            if (!isClosed() && id != null) {
                // we don't need to retry this operation in the case of failure
                // as ZK will remove ephemeral files and we don't wanna hang
                // this process when closing if we cannot reconnect to ZK
                try {
                    ZooKeeperOperation zopdel = new ZooKeeperOperation() {
                        public boolean execute() throws KeeperException,
                            InterruptedException {
                            zookeeper.delete(id, -1);   
                            return Boolean.TRUE;
                        }
                    };
                    zopdel.execute();
                } catch (InterruptedException e) {
                    LOG.warn("Caught: " + e, e);
                    //set that we have been interrupted.
                   Thread.currentThread().interrupt();
                } catch (KeeperException.NoNodeException e) {
                    // do nothing
                } catch (KeeperException e) {
                    LOG.warn("Caught: " + e, e);
                    throw (RuntimeException) new RuntimeException(e.getMessage()).
                        initCause(e);
                }
                finally {
                    if (callback != null) {
                        callback.lockReleased();
                    }
                    id = null;
                }
            }
        }
        
        /** 
         * the watcher called on  
         * getting watch while watching 
         * my predecessor
         */
        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();
                } catch (Exception e) {
                    LOG.warn("Failed to acquire lock: " + e, e);
                }
            }
        }
        
        /**
         * a zoookeeper operation that is mainly responsible
         * for all the magic required for locking.
         */
        private  class LockZooKeeperOperation implements ZooKeeperOperation {
            
            /** find if we have been created earler if not create our node
             * 
             * @param prefix the prefix node
             * @param zookeeper teh zookeeper client
             * @param dir the dir paretn
             * @throws KeeperException
             * @throws InterruptedException
             */
            private void findPrefixInChildren(String prefix, ZooKeeper zookeeper, String dir) 
                throws KeeperException, InterruptedException {
                List<String> names = zookeeper.getChildren(dir, false);
                for (String name : names) {
                    if (name.startsWith(prefix)) {
                        id = dir + "/" + name;
                        if (LOG.isDebugEnabled()) {
                            LOG.debug("Found id created last time: " + id);
                        }
                        break;
                    }
                }
                if (id == null) {
                    id = zookeeper.create(dir + "/" + prefix, data, 
                            getAcl(), EPHEMERAL_SEQUENTIAL);
    
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Created id: " + id);
                    }
                }
    
            }
            
            /**
             * the command that is run and retried for actually 
             * obtaining the lock
             * @return if the command was successful or not
             */
            public boolean execute() throws KeeperException, InterruptedException {
                do {
                    if (id == null) {
                        long sessionId = zookeeper.getSessionId();
                        String prefix = "x-" + sessionId + "-";
                        // lets try look up the current ID if we failed 
                        // in the middle of creating the znode
                        findPrefixInChildren(prefix, zookeeper, dir);
                        idName = new ZNodeName(id);
                    }
                    if (id != null) {
                        List<String> names = zookeeper.getChildren(dir, false);
                        if (names.isEmpty()) {
                            LOG.warn("No children in: " + dir + " when we've just " +
                            "created one! Lets recreate it...");
                            // lets force the recreation of the id
                            id = null;
                        } else {
                            // lets sort them explicitly (though they do seem to come back in order ususally :)
                            SortedSet<ZNodeName> sortedNames = new TreeSet<ZNodeName>();
                            for (String name : names) {
                                sortedNames.add(new ZNodeName(dir + "/" + name));
                            }
                            ownerId = sortedNames.first().getName();
                            SortedSet<ZNodeName> lessThanMe = sortedNames.headSet(idName);
                            if (!lessThanMe.isEmpty()) {
                                ZNodeName lastChildName = lessThanMe.last();
                                lastChildId = lastChildName.getName();
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("watching less than me node: " + lastChildId);
                                }
                                Stat stat = zookeeper.exists(lastChildId, new LockWatcher());
                                if (stat != null) {
                                    return Boolean.FALSE;
                                } else {
                                    LOG.warn("Could not find the" +
                                            " stats for less than me: " + lastChildName.getName());
                                }
                            } else {
                                if (isOwner()) {
                                    if (callback != null) {
                                        callback.lockAcquired();
                                    }
                                    return Boolean.TRUE;
                                }
                            }
                        }
                    }
                }
                while (id == null);
                return Boolean.FALSE;
            }
        };
    
        /**
         * Attempts to acquire the exclusive write lock returning whether or not it was
         * acquired. Note that the exclusive lock may be acquired some time later after
         * this method has been invoked due to the current lock owner going away.
         */
        public synchronized boolean lock() throws KeeperException, InterruptedException {
            if (isClosed()) {
                return false;
            }
            ensurePathExists(dir);
    
            return (Boolean) retryOperation(zop);
        }
    
        /**
         * return the parent dir for lock
         * @return the parent dir used for locks.
         */
        public String getDir() {
            return dir;
        }
    
        /**
         * Returns true if this node is the owner of the
         *  lock (or the leader)
         */
        public boolean isOwner() {
            return id != null && ownerId != null && id.equals(ownerId);
        }
    
        /**
         * return the id for this lock
         * @return the id for this lock
         */
        public String getId() {
           return this.id;
        }
    }
    复制代码

    注意这里的lock,可能会失败,会尝试多次,每次失败后会Sleep一段时间。

    PS:官方的代码有个小bug,id和ownerId应该都是全路径,即id = dir + "/" + name;原代码在findPrefixInChildren里有问题。

    用于辅助节点大小顺序排序的类:

     View Code

    PS:这个ZNodeName类是被我修改过的,官方的代码比较有问题,官方的先用了节点路径的前缀prefix比较,再去比较sequence序号是不对的,这样会导致sessionid小的总是能拿到锁。应该直接比较全局有序的sequence序号,小的先拿到锁,先到先得。

    Zookeeper统一操作ZooKeeperOperation接口:

     View Code

    因为Zookeeper的操作会失败,这个类封装了多次尝试:

     View Code

    这个类是本客户端获取到lock和释放lock的时候触发操作的接口:

     View Code

    队列(Queue)

    分布式队列是通用的数据结构,为了在 Zookeeper 中实现分布式队列,首先需要指定一个 Znode 节点作为队列节点(queue node), 各个分布式客户端通过调用 create() 函数向队列中放入数据,调用create()时节点路径名带"qn-"结尾,并设置顺序(sequence)节点标志。 由于设置了节点的顺序标志,新的路径名具有以下字符串模式:"_path-to-queue-node_/qn-X",X 是唯一自增号。需要从队列中获取数据/移除数据的客户端首先调用 getChildren() 函数,有数据则获取(获取数据后可以删除也可以不删),没有则在队列节点(queue node)上将 watch 设置为 true,等待触发并处理最小序号的节点(即从序号最小的节点中取数据)。

    实现步骤基本如下:

    前提:需要一个队列root节点dir

    入队:使用create()创建节点,将共享数据data放在该节点上,节点类型为PERSISTENT_SEQUENTIAL,永久顺序性的(也可以设置为临时的,看需求)。

    出队:因为队列可能为空,2种方式处理:一种如果为空则wait等待,一种返回异常。

    等待方式:这里使用了CountDownLatch的等待和Watcher的通知机制,使用了TreeMap的排序获取节点顺序最小的数据(FIFO)。

    抛出异常:getChildren()获取队列数据时,如果size==0则抛出异常。

    一个分布式Queue的实现,详细代码:

     View Code

    Apache Curator

    Curator是一个封装Zookeeper操作的库,使用这个库的好处是Curator帮你管理和Zookeeper的连接,当连接有问题时会自动重试(retry)。

    RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3)
    CuratorFramework client = CuratorFrameworkFactory.newClient(zookeeperConnectionString, retryPolicy);
    client.start();

    Curator已经封装了一些常用的Recipes

    Distributed Lock

    复制代码
    InterProcessMutex lock = new InterProcessMutex(client, lockPath);
    if ( lock.acquire(maxWait, waitUnit) ) 
    {
        try 
        {
            // do some work inside of the critical section here
        }
        finally
        {
            lock.release();
        }
    }
    复制代码

    Leader Election

    复制代码
    LeaderSelectorListener listener = new LeaderSelectorListenerAdapter()
    {
        public void takeLeadership(CuratorFramework client) throws Exception
        {
            // this callback will get called when you are the leader
            // do whatever leader work you need to and only exit
            // this method when you want to relinquish leadership
        }
    }
    
    LeaderSelector selector = new LeaderSelector(client, path, listener);
    selector.autoRequeue();  // not required, but this is behavior that you will probably expect
    selector.start(); 
    复制代码

    参考:

    http://zookeeper.apache.org/doc/trunk/recipes.html

    http://curator.apache.org/curator-recipes/index.html

    作者:阿凡卢
    本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
  • 相关阅读:
    node作为反向代理服务器
    引擎模板jade常见用法
    express4中模板引擎ejs
    express4+mysql博客项目
    关于zepto需要注意的地方
    css中需要注意的地方
    typescript基础类型
    vue全文搜索高亮显示
    js搜索全文高亮显示
    js随机验证码
  • 原文地址:https://www.cnblogs.com/panxuejun/p/8575149.html
Copyright © 2011-2022 走看看