分布式锁的几种实现方式

2023年6月5日 340次阅读 来源: zhuke

分布式锁是控制分布式系统之间同步访问共享资源的一种方式。
其典型的使用场景为：
不同系统或者是同一系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，需要通过一定的互斥手段来防止彼此的干扰，以保证一致性。

1. 使用Redis实现分布式锁

* WATCH, MULTI, EXEC, DISCARD事务机制实现分布式锁

Redis支持基本的事务操作

MULTI
some redis command
EXEC

以上被MULTI和EXEC包裹的redis命令，保证所有事务内的命令将会串行顺序执行，保证不会在事务的执行过程中被其他客户端打断。
而WATCH命令能够监视某个键，当事务执行时，如果被监视的键被其他客户端修改了值，事务运行失败，返回相应错误（被事务运行客户端在事务内修改了值，不会造成事务运行失败）。

运用Redis事务所支持的以上特性，可以实现一个分布式锁功能。Python代码如下：

# -*- coding: utf-8 -*-
def acqure_lock_with_watch(conn, lockname, acquire_timeout=10):
    pipe = conn.pipeline()
    end = time.time() + acquire_timeout
    lockname = 'lock:' + lockname

    while time.time() < end:
        try:
            pipe.watch(lockname)
            pipe.multi()  # 开启事务
            # 事务具体内容，对lockname的值进行更新
            pipe.execute()
            return True
        except redis.exceptions.WatchError:
            # 事务运行期间，有其他客户端改变了lockname的值，抛出异常，进行重试操作
            pass

    return False

通过WATCH命令监视某个键，当该键未被其他客户端修改值时，事务成功执行。当事务运行过程中，发现该值被其他客户端更新了值，任务失败，进行重试。

* SETNX实现分布式锁

SETNX：当指定键不存在时，向Redis中添加一个键值对。Redis客户端保证对统一键名称，多个客户端同时设置其值时，只有一个客户端能够设置成功的原子性。

# -*- coding: utf-8 -*-
def acquire_lock_with_timeout(
        conn, lockname, acquire_timeout=10, lock_timeout=10):
    identifire = str(uuid.uuid4())
    lockname = 'lock:' + lockname
    lock_timeout = int(math.ceil(lock_timeout))

    end = time.time() + acquire_timeout
    while time.time() < end:
        if conn.setnx(lockname, identifire):  # 以锁名称为键，uuid的值为值，redis服务器setnx保证了只能有一个客户端成功设置键的原子性
            conn.expire(lockname, lock_timeout)  # 设置键的过期时间，过期自动剔除，释放锁
            return identifire
        elif not conn.ttl(lockname):  # 当锁未被设置过期时间时，重新设置其过期时间
            conn.expire(lockname, lock_timeout)

        time.sleep(0.001)

    return False

以上，利用SETNX的原子特性，和Redis的键过期特性，实现了自动过期释放的分布式锁。

* 锁的释放

# -*- coding: utf-8 -*-
def release_lock(conn, lockname, identifire):
    pipe = conn.pipeline(True)
    lockname = 'lock:' + lockname

    while True:
        try:
            pipe.watch(lockname)  # 监视锁的键，在锁释放过程中改变了键的值时得到相应通知
            if pipe.get(lockname) == identifire:  # 检查客户端是否仍然持有该锁
                pipe.multi()
                pipe.delete(lockname)  # 删除键，释放锁
                pipe.execute()
                return True

            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass  # 释放锁期间，有其他客户端改变了键值对，锁释放失败，进行循环

    return False

锁释放的过程，首先检查客户端是否仍然持有该锁，如果持有，则在事务中删除键值对，释放锁的所有权。

2. 使用Memcached实现分布式锁

Memcached的add命令，当指定的key不存在时，进行添加，且保证了执行的原子性。利用该特性，可以实现一个分布式锁实现。

def acquire_lock_with__memcached_timeout(
        conn, lockname, acquire_timeout=10, lock_timeout=10):
    identifire = str(uuid.uuid4())
    lockname = 'lock:' + lockname
    lock_timeout = int(math.ceil(lock_timeout))

    end = time.time() + acquire_timeout
    while time.time() < end:
        # 过期时间保证了客户端崩溃时仍能在超过过期世家后正常释放锁
        # 以锁名称为键，uuid的值为值，memcached服务器add保证了只能有一个客户端成功设置键的原子性
        if conn.add(lockname, identifire, lock_timeout):
            return identifire
        time.sleep(0.001)

    return False

释放锁时，删除指定key的键即可。

3. 使用ZooKeeper实现分布式锁

相较于使用redis和memcached实现的锁，zk利用其高级特性，能够实现更复杂的锁特性。

  • 排它锁

排它锁，又称写锁或独占锁。如果事务T1对对象O1加了排它锁，那么整个加锁期间，只允许事务T1对O1进行读取和更新操作，其他任何事务都不能对该数据对象进行任务读写操作，直到T1释放了排它锁。
以上介绍的使用redis和memcached实现的分布式锁都属于排它锁。

获取锁

ZooKeeper实现分布式锁利用了其临时子节点的如下特性：
在/exclusive_lock节点下创建临时子节点/exclusive_lock/lock，zk会保证在所有的客户端中，最终只有一个客户端能够创建成功，即可以认为该客户端获得了锁。同时，虽有没有获取到所得客户端需要到/exclusive_lock节点上注册一个子节点变更的Watcher监听，以便实时监听到lock节点的变更情况。

释放锁

因为在获取锁时，创建的是一个临时节点/exclusive_lock/lock，因此在如下情况，都有可能释放锁：

  • 获取锁的机器发生宕机，临时节点被zk移除
  • 正常执行业务逻辑后，客户端主动删除临时节点

无论什么情况下，lock节点被移除，zk都会通知所有在/exclusive_lock节点上注册了子节点变更的Watcher监听的客户端。这些客户端在收到通知后，重新发起分布式锁的获取流程。

  • 共享锁

共享锁又称读锁。如果事务T1对数据对象O1加上了共享锁，那么当前事务只能对O1进行读取操作，其他事务也只能对这个数据对象加上共享锁，直到该数据对象上的所有共享锁都被释放。
而更新操作只能在当前没有任何事务进行读写操作的情况下进行。

获取锁

当需要获取共享锁是，所有客户端到/shared_lock节点下面创建一个临时顺序节点，/shared_lock/[hostname]-请求类型（W | R）-序号，该节点代编了一个共享锁。
如果是读请求，则创建/shared_lock/192.168.0.1-R-000000000001；
如果是写请求，则创建/shared_lock/192.168.0.1-W-000000000001；

判断读写顺序

  1. 在创建完监听后，获取/shared_lock节点下的所有子节点，对该节点注册子节点变更的Watcher监听
  2. 确定自己的节点序号在所有子节点的顺序
  3. 对于读请求：

如果没有比自己序号小的子节点，或是所有比自己序号小的子节点都是读请求，那么表明自己已经成功获取到了共享锁，执行读取逻辑。
如果比自己序号小的子节点中有写请求，那么进入等待。

  1. 对于写请求：

如果自己不是序号最小的子节点，那么进入等待。

  1. 收到Watcher通知后，重复步骤1-4
释放锁

释放锁，删除对应的数据节点即可。

参考资料：

《从Paxos到ZooKeeper分布式一致性原理与实践》 – 倪超 著
https://redis.io/topics/transactions

http://redisbook.readthedocs.io/en/latest/feature/transaction.html

    原文作者：zhuke
    原文地址: https://www.jianshu.com/p/83881a79a0c8
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞