分布式锁的几种实现方式

分布式锁的几种实现方式

分布式锁是控制分布式系统之间同步访问共享资源的一种方式。

其典型的使用场景为：

不同系统或者是同一系统的不同主机之间共享了一个或一组资源，那么访问这些资源的时候，需要通过

一定的互斥手段来防止彼此的干扰，以保证一致性。

1. 使用Redis实现分布式锁

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

Redis支持基本的事务操作

以上被MULTI和EXEC包裹的redis命令，保证所有事务内的命令将会串行顺序执行，保证不会在事务的执

行过程中被其他客户端打断。

而WATCH命令能够监视某个键，当事务执行时，如果被监视的键被其他客户端修改了值，事务运行失

败，返回相应错误（被事务运行客户端在事务内修改了值，不会造成事务运行失败）。

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

通过WATCH命令监视某个键，当该键未被其他客户端修改值时，事务成功执行。当事务运行过程中，发

现该值被其他客户端更新了值，任务失败，进行重试。

MULTI

some redis command

EXEC

# -*- 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* SETNX实现分布式锁

SETNX：当指定键不存在时，向Redis中添加一个键值对。Redis客户端保证对统一键名称，多个客户端

同时设置其值时，只有一个客户端能够设置成功的原子性。

以上，利用SETNX的原子特性，和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

# -*- 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 False2. 使用Memcached实现分布式锁

Memcached的add命令，当指定的key不存在时，进行添加，且保证了执行的原子性。利用该特性，可

以实现一个分布式锁实现。

释放锁时，删除指定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进行读取操作，其

他事务也只能对这个数据对象加上共享锁，直到该数据对象上的所有共享锁都被释放。

而更新操作只能在当前没有任何事务进行读写操作的情况下进行。

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获取锁

当需要获取共享锁是，所有客户端到/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

释放锁

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