分布式问题——常用分布式锁的实现原理和步骤

阳光穿透心脏的1/2处 2021-11-13 22:12 220阅读 0赞

### 分布式问题——常用分布式锁的实现原理和步骤 ###

*   *  什么是分布式锁?
     *  常用的分布式锁有哪些？
     *   *  1.利用数据库实现排他锁
         *  2.基于redis实现分布式锁
         *  3.zookeeper做分布式锁
         *  4.基于consul实现分布式锁
         *  方式对比：

## 什么是分布式锁? ##

在开发中需要对某一个数据的值或状态进行改变的时候，为了保证数据的安全，在单应用下(也就是单个jvm中)，我们往往采用加锁的方式实现，比如：lock锁、synchronized。  
但是在高并发、高性能的场景下需要采用分布式应用，这种情况下程序运行在多个不同的jvm中，为了达到和单机版(单个jvm)一样的效果，就需要引入分布式锁的技术。  
如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE_size_16_color_FFFFFF_t_70]

## 常用的分布式锁有哪些？ ##

### 1.利用数据库实现排他锁 ###

***方案一：*** 利用表字段的唯一约束

CREATE TABLE `td_lock` (
      `id` int(10) NOT NULL AUTO_INCREMENT COMMENT '主键',
      `lock_name` varchar(100) NOT NULL DEFAULT '' COMMENT '锁定的方法名',
      `descr` varchar(300) NOT NULL COMMENT '备注信息',
      `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
      PRIMARY KEY (`id`),
      UNIQUE KEY `lock_name` (`lock_name`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

在要同步数据的方法中使用

insert into td_lock(ilock_name,descr) values(类名.方法名,备注);

如果插入成功，则表示获取锁，插入失败则获取锁失败，可以进行重试。

***方案二：*** 基于数据库存储引擎InnoDB做排他锁  
创建一个表，每次查询的时候在后面加上`for update;` ,数据库会在该sql查询的时候给数据库添加排他锁进行锁定，这时候`其它查询就会阻塞`。执行完业务逻辑之后`通过connection.commit()来释放锁`。

***优点：***  
实现起来比较简单，易于操作和理解。  
***缺点：***  
数据库单点问题是分布式锁失效，也就是点单问题。  
频繁的数据操作，会大大增加数据库的访问压力。  
没有办法设置失效时间，一旦某个操作失败，可能其它线程可能一直无法获得锁。

### 2.基于redis实现分布式锁 ###

首先明白set()和setnx()命令的区别：set()当key存在时可以覆盖value,setnx()则不会覆盖value;  
***方案一：*** 通过redis的setnx()和expire()命令实现

*  Long flag = setnx(String key,String value)  
    如果key已经存在则返回值flag=0，什么也不做，如果key不存在返回flag=1，添加key成功；
 *  expire(String key,int seconds)；设置超时时间，避免死锁问题。
 *  del(String key); 业务处理完成后，删除setnx设置的键。

***缺点*** 这个方案其实是可以解决日常工作中的需求的，但从技术方案的探讨上来说，可能还有一些可以完善的地方。比如，如果在第一步 setnx 执行成功后，在 expire() 命令执行成功前，发生了宕机的现象，那么就依然会出现死锁的问题，所以如果要对其进行完善的话，可以使用 redis 的 setnx()、get() 和 getset() 方法来实现分布式锁。  
***方案二：*** 基于redis的setnx()、get()、getset()方法

*  getset(key，newValue)：该方法是原子的，对 key 设置 newValue 这个值，并且返回 key 原来的旧值。假设 key 原来是不存在的，那么就返回null.
 *  实现步骤：

1.  setnx(lockkey, 当前时间+过期超时时间)，如果返回 1，则获取锁成功；如果返回 0 则没有获取到锁，转向 2。
2.  get(lockkey) 获取值 oldExpireTime ，并将这个 value 值与当前的系统时间进行比较，如果小于当前系统时间，则认为这个锁已经超时，可以允许别的请求重新获取，转向 3。
3.  计算 newExpireTime = 当前时间+过期超时时间，然后 getset(lockkey, newExpireTime) 会返回当前 lockkey 的值currentExpireTime。
4.  判断 currentExpireTime 与 oldExpireTime 是否相等，如果相等，说明当前 getset 设置成功，获取到了锁。如果不相等，说明这个锁又被别的请求获取走了，那么当前请求可以直接返回失败，或者继续重试。
5.  在获取到锁之后，当前线程可以开始自己的业务处理，当处理完毕后，比较自己的处理时间和对于锁设置的超时时间，如果小于锁设置的超时时间，则直接执行 delete 释放锁；如果大于锁设置的超时时间，则不需要再锁进行处理。  
    ***方案三：*** 基于 redlock做分布式锁  
    Redlock 是 Redis 的作者 antirez 给出的集群模式的 Redis 分布式锁，它基于 N 个完全独立的 Redis 节点（通常情况下 N 可以设置成 5）。

*  算法的步骤如下：
    
    1.  客户端获取当前时间，以毫秒为单位。
    2.  客户端尝试获取 N 个节点的锁，（每个节点获取锁的方式和前面说的缓存锁一样），N 个节点以相同的 key 和 value 获取锁。客户端需要设置接口访问超时，接口超时时间需要远远小于锁超时时间，比如锁自动释放的时间是 10s，那么接口超时大概设置 5-50ms。这样可以在有 redis 节点宕机后，访问该节点时能尽快超时，而减小锁的正常使用。
    3.  客户端计算在获得锁的时候花费了多少时间，方法是用当前时间减去在步骤一获取的时间，只有客户端获得了超过 3 个节点的锁，而且获取锁的时间小于锁的超时时间，客户端才获得了分布式锁。  
        4.客户端获取的锁的时间为设置的锁超时时间减去步骤三计算出的获取锁花费时间。
    4.  如果客户端获取锁失败了，客户端会依次删除所有的锁。  
        使用 Redlock 算法，可以保证在挂掉最多 2 个节点的时候，分布式锁服务仍然能工作，这相比之前的数据库锁和缓存锁大大提高了可用性，由于 redis 的高效性能，分布式缓存锁性能并不比数据库锁差。

但是，有一位分布式的专家写了一篇文章《How to do distributed locking》，质疑 Redlock 的正确性。

https://mp.weixin.qq.com/s/1bPLk\_VZhZ0QYNZS8LkviA

https://blog.csdn.net/jek123456/article/details/72954106

***优点：*** 性能高

***缺点：*** 失效时间设置多长时间为好？如何设置的失效时间太短，方法没等执行完，锁就自动释放了，那么就会产生并发问题。如果设置的时间太长，其他获取锁的线程就可能要平白的多等一段时间。

### 3.zookeeper做分布式锁 ###

***相关知识：***

*  zk 一般由多个节点构成（单数），采用 zab 一致性协议。因此可以将 zk 看成一个单点结构，对其修改数据其内部自动将所有节点数据进行修改而后才提供查询服务。
 *  zk 的数据以目录树的形式，每个目录称为 znode， znode 中可存储数据（一般不超过 1M），还可以在其中增加子节点。
 *  子节点有两种类型。持久节点客户端与zookeeper断开连接后，该节点依旧存在。临时节点，一旦创建这个 znode 的客户端与服务器失去联系，这个 znode 也将自动删除。
 *  Watch 机制，client 可以监控每个节点的变化，当产生变化会给 client 产生一个事件。  
    ***方案一：*** `基于zk的临时节点与watch机制`
    
     *  原理： 创建一个普通节点/lock,当线程需要获取锁时，就在/lock节点下创建一个临时节点，创建成功则表示获取锁成功，失败则利用watch /lock节点，有删除节点时再去争取锁。临时节点的好处在于当进程挂掉后能自动删除上锁的节点，所以不会发生死锁现象。
     *  缺点： 所有获取锁失败的进程都监听父节点，很容易发生羊群效应，即当释放锁后所有等待进程都一起去创建节点，并发量很大。  
        ***方案二：*** `基于zk的临时有效节点与watch机制`
 *  原理：上锁改为创建临时有序节点，每个上锁的节点均能创建节点成功，只是其序号不同。只有序号最小的可以拥有锁，如果这个节点序号不是最小的则 watch 序号比本身小的前一个节点 (公平锁)。
 *  步骤：
    
    1.  在 /lock 节点下创建一个有序临时节点 (EPHEMERAL\_SEQUENTIAL)。
    2.  判断创建的节点序号是否最小，如果是最小则获取锁成功。不是则取锁失败，然后 watch 序号比本身小的前一个节点。
    3.  当取锁失败，设置 watch 后则等待 watch 事件到来后，再次判断是否序号最小。
    4.  取锁成功则执行代码，最后释放锁（删除该节点）。

import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    
    import org.apache.zookeeper.CreateMode;
    import org.apache.zookeeper.KeeperException;
    import org.apache.zookeeper.WatchedEvent;
    import org.apache.zookeeper.Watcher;
    import org.apache.zookeeper.ZooDefs;
    import org.apache.zookeeper.ZooKeeper;
    import org.apache.zookeeper.data.Stat;
    
    public class DistributedLock implements Lock, Watcher{ 
        private ZooKeeper zk;
        private String root = "/locks";//根
        private String lockName;//竞争资源的标志
        private String waitNode;//等待前一个锁
        private String myZnode;//当前锁
        private CountDownLatch latch;//计数器
        private int sessionTimeout = 30000;
        private List<Exception> exception = new ArrayList<Exception>();
    
        /** * 创建分布式锁,使用前请确认config配置的zookeeper服务可用 * @param config 127.0.0.1:2181 * @param lockName 竞争资源标志,lockName中不能包含单词lock */
        public DistributedLock(String config, String lockName){ 
            this.lockName = lockName;
            // 创建一个与服务器的连接
            try { 
                zk = new ZooKeeper(config, sessionTimeout, this);
                Stat stat = zk.exists(root, false);
                if(stat == null){ 
                    // 创建根节点
                    zk.create(root, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.PERSISTENT);
                }
            } catch (IOException e) { 
                exception.add(e);
            } catch (KeeperException e) { 
                exception.add(e);
            } catch (InterruptedException e) { 
                exception.add(e);
            }
        }
    
        /** * zookeeper节点的监视器 */
        public void process(WatchedEvent event) { 
            if(this.latch != null) { 
                this.latch.countDown();
            }
        }
    
        public void lock() { 
            if(exception.size() > 0){ 
                throw new LockException(exception.get(0));
            }
            try { 
                if(this.tryLock()){ 
                    System.out.println("Thread " + Thread.currentThread().getId() + " " +myZnode + " get lock true");
                    return;
                }
                else{ 
                    waitForLock(waitNode, sessionTimeout);//等待锁
                }
            } catch (KeeperException e) { 
                throw new LockException(e);
            } catch (InterruptedException e) { 
                throw new LockException(e);
            }
        }
    
        public boolean tryLock() { 
            try { 
                String splitStr = "_lock_";
                if(lockName.contains(splitStr))
                    throw new LockException("lockName can not contains \\u000B");
                //创建临时子节点
                myZnode = zk.create(root + "/" + lockName + splitStr, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE,CreateMode.EPHEMERAL_SEQUENTIAL);
                System.out.println(myZnode + " is created ");
                //取出所有子节点
                List<String> subNodes = zk.getChildren(root, false);
                //取出所有lockName的锁
                List<String> lockObjNodes = new ArrayList<String>();
                for (String node : subNodes) { 
                    String _node = node.split(splitStr)[0];
                    if(_node.equals(lockName)){ 
                        lockObjNodes.add(node);
                    }
                }
                Collections.sort(lockObjNodes);
                System.out.println(myZnode + "==" + lockObjNodes.get(0));
                if(myZnode.equals(root+"/"+lockObjNodes.get(0))){ 
                    //如果是最小的节点,则表示取得锁
                    return true;
                }
                //如果不是最小的节点，找到比自己小1的节点
                String subMyZnode = myZnode.substring(myZnode.lastIndexOf("/") + 1);
                waitNode = lockObjNodes.get(Collections.binarySearch(lockObjNodes, subMyZnode) - 1);
            } catch (KeeperException e) { 
                throw new LockException(e);
            } catch (InterruptedException e) { 
                throw new LockException(e);
            }
            return false;
        }
    
        public boolean tryLock(long time, TimeUnit unit) { 
            try { 
                if(this.tryLock()){ 
                    return true;
                }
                return waitForLock(waitNode,time);
            } catch (Exception e) { 
                e.printStackTrace();
            }
            return false;
        }
    
        private boolean waitForLock(String lower, long waitTime) throws InterruptedException, KeeperException { 
            Stat stat = zk.exists(root + "/" + lower,true);
            //判断比自己小一个数的节点是否存在,如果不存在则无需等待锁,同时注册监听
            if(stat != null){ 
                System.out.println("Thread " + Thread.currentThread().getId() + " waiting for " + root + "/" + lower);
                this.latch = new CountDownLatch(1);
                this.latch.await(waitTime, TimeUnit.MILLISECONDS);
                this.latch = null;
            }
            return true;
        }
    
        public void unlock() { 
            try { 
                System.out.println("unlock " + myZnode);
                zk.delete(myZnode,-1);
                myZnode = null;
                zk.close();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (KeeperException e) { 
                e.printStackTrace();
            }
        }
    
        public void lockInterruptibly() throws InterruptedException { 
            this.lock();
        }
    
        public Condition newCondition() { 
            return null;
        }
    
        public class LockException extends RuntimeException { 
            private static final long serialVersionUID = 1L;
            public LockException(String e){ 
                super(e);
            }
            public LockException(Exception e){ 
                super(e);
            }
        }
    }

*  优点:有效的解决单点问题，不可重入问题，非阻塞问题以及锁无法释放的问题。实现起来较为简单。
 *  缺点：性能上可能并没有缓存服务那么高，因为每次在创建锁和释放锁的过程中，都要动态创建、销毁临时节点来实现锁功能。ZK 中创建和删除节点只能通过 Leader 服务器来执行，然后将数据同步到所有的 Follower 机器上。还需要对 ZK的原理有所了解。

### 4.基于consul实现分布式锁 ###

***相关知识：***

*  acquire操作只有当锁不存在持有者时才会返回true，并且set设置的Value值，同时执行操作的session会持有对该Key的锁，否则就返回false。
 *  release操作则是使用指定的session来释放某个Key的锁，如果指定的session无效，那么会返回false，否则就会set设置Value值，并返回true。

***具体实现：***

public class Lock { 
     
        private static final String prefix = "lock/";  // 同步锁参数前缀
     
        private ConsulClient consulClient;
        private String sessionName;
        private String sessionId = null;
        private String lockKey;
     
        /** * * @param consulClient * @param sessionName 同步锁的session名称 * @param lockKey 同步锁在consul的KV存储中的Key路径，会自动增加prefix前缀，方便归类查询 */
        public Lock(ConsulClient consulClient, String sessionName, String lockKey) { 
            this.consulClient = consulClient;
            this.sessionName = sessionName;
            this.lockKey = prefix + lockKey;
        }
     
        /** * 获取同步锁 * * @param block 是否阻塞，直到获取到锁为止 * @return */
        public Boolean lock(boolean block) { 
            if (sessionId != null) { 
                throw new RuntimeException(sessionId + " - Already locked!");
            }
            sessionId = createSession(sessionName);
            while(true) { 
                PutParams putParams = new PutParams();
                putParams.setAcquireSession(sessionId);
                if(consulClient.setKVValue(lockKey, "lock:" + LocalDateTime.now(), putParams).getValue()) { 
                    return true;
                } else if(block) { 
                    continue;
                } else { 
                    return false;
                }
            }
        }
     
        /** * 释放同步锁 * * @return */
        public Boolean unlock() { 
            PutParams putParams = new PutParams();
            putParams.setReleaseSession(sessionId);
            boolean result = consulClient.setKVValue(lockKey, "unlock:" + LocalDateTime.now(), putParams).getValue();
            consulClient.sessionDestroy(sessionId, null);
            return result;
        }
     
        /** * 创建session * @param sessionName * @return */
        private String createSession(String sessionName) { 
            NewSession newSession = new NewSession();
            newSession.setName(sessionName);
            return consulClient.sessionCreate(newSession, null).getValue();
        }
     
    }

***缺点：*** 存在unlock()无法执行导致死锁现象。

### 方式对比： ###

*  三种方案的比较从理解的难易程度角度（从低到高）: 数据库 > 缓存 > Zookeeper
 *  从实现的复杂性角度（从低到高）: Zookeeper >= 缓存 > 数据库
 *  从性能角度（从高到低）: 缓存 > Zookeeper >= 数据库
 *  从可靠性角度（从高到低）: Zookeeper > 缓存 > 数据库

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5nMTgyMzgwMzI4OTE_size_16_color_FFFFFF_t_70]: /images/20211113/bdf06d3fb460497e81a441fb8a5be84f.png