1:分布式锁
- 分布式锁主要用于在分布式环境中保护跨进程、跨主机、跨网络的共享资源实现互斥访问,以达到保证数据一致性。
2:概念介绍
- 持久节点(PERSISTENT)
所谓持久节点,是指在节点创建后,就一直存在,直到有删除操作来主动清除这个节点——不会因为创建该节点的客户端会话失效而消失。
- 持久顺序节点(PERSISTENT_SEQUENTIAL)
这类节点的基本特性和上面的节点类型是一致的。额外的特性是,在ZK中,每个父节点会为他的第一级子节点维护一份时序,会记录每个子节点创建的先后顺序。基于这个特性,在创建子节点的时候,可以设置这个属性,那么在创建节点过程中,ZK会自动为给定节点名加上一个数字后缀,作为新的节点名。这个数字后缀的范围是整型的最大值。
- 临时节点(EPHEMERAL)
和持久节点不同的是,临时节点的生命周期和客户端会话绑定。也就是说,如果客户端会话失效,那么这个节点就会自动被清除掉。注意,这里提到的是会话失效,而非连接断开。另外,在临时节点下面不能创建子节点。
- 临时顺序节点(EPHEMERAL_SEQUENTIAL)
临时节点的生命周期和客户端会话绑定,并且会有一个时序编号(如0000000001)。可以用来实现分布式锁
3:架构图
4:分布式锁实现思路
- 首先在ZK上创建持久节点(如locker),然后在持久节点(locker)下创建临时顺序节点。(释放锁时记得删除该临时顺序节点)
- 获取持久节点下所有的临时顺序节点,然后按其节点序号对其进行从小到大排序,判断自己的节点序号是不是最小的,如果是则获得锁。
- 如果不是,对自己节点序号前一个节点序号的临时顺序进行watch事件监听,如果前一个临时顺序节点被删除,则会收到事件通知,此时再判断自己是否是最小的临时顺序节点(即重复2、3步骤),直到获得锁。
备注:只针对临时顺序节点前一个节点进行事件监听,是因为如果对所有临时顺序节点进行事件监听,则如果一个节点释放锁,必然引起其余所有节点去抢锁,浪费资源,也就是惊群效应。
代码样例:
# -*- coding:utf-8 -*-
import logging, os, time
from kazoo.client import KazooClient
from kazoo.client import KazooState
from kazoo.recipe.lock import Lock
logging.basicConfig()
class ZooKeeperLock():
def __init__(self, hosts, lock_path, lock_name, lock_value, timeout=1):
self.hosts = hosts
self.zk_client = None
self.timeout = timeout
self.name = lock_name
self.lock_path = "PolicyCtrlCent/" + lock_path + "/" + lock_name
self.lock_value = lock_value
self.lock_handle = None
self.create_lock()
def create_lock(self):
try:
self.zk_client = KazooClient(hosts=self.hosts, timeout=self.timeout)
@self.zk_client.add_listener
def my_listener(state):
if state == KazooState.LOST:
print("LOST")
elif state == KazooState.SUSPENDED:
print("SUSPENDED")
else:
print("Connected")
self.zk_client.start(timeout=self.timeout)
self.add_zk_auth()
except Exception, ex:
self.init_ret = False
self.err_str = "Create KazooClient failed! Exception: %s" % str(ex)
try:
print self.lock_path
self.lock_handle = Lock(self.zk_client, self.lock_path)
self.zk_client.set(self.lock_path, self.lock_value)
except Exception, ex:
self.init_ret = False
self.err_str = "Create lock failed! Exception: %s" % str(ex)
from kazoo.security import make_digest_acl
client = self.zk_client
acl = make_digest_acl('pcm', 'pcm', all=True)
try:
client.set_acls(self.lock_path, [acl])
finally:
print("set KazooClient acl SUCCESS!")
def destroy_lock(self):
# self.release()
if self.zk_client != None:
self.zk_client.stop()
self.zk_client = None
def acquire(self, blocking=True, timeout=None):
if self.lock_handle == None:
return None
try:
return self.lock_handle.acquire(blocking=blocking, timeout=timeout)
except Exception, ex:
self.err_str = "Acquire lock failed! Exception: %s" % str(ex)
return None
def release(self):
if self.lock_handle == None:
return None
return self.lock_handle.release()
def __del__(self):
self.destroy_lock()
def _makeAuth(self, *args, **kwargs):
from kazoo.security import make_digest_acl
return make_digest_acl(*args, **kwargs)
def add_zk_auth(self):
username = "pcm"
password = "pcm"
digest_auth = "%s:%s" % (username, password)
acl = self._makeAuth(username, password, all=True)
self.zk_client.add_auth("digest", digest_auth)
self.zk_client.default_acl = (acl,)
print("add zk_auth SUCCESS!")
def main():
zookeeper_hosts = "127.0.0.1:2181"
lock_name = "test"
pid = str(os.getpid())
lock = ZooKeeperLock(zookeeper_hosts, "asdqe", lock_name, pid)
print "a"
ret = lock.acquire(timeout=3)
print ret
print "b"
if not ret:
return
for i in range(1, 10):
time.sleep(1)
print i
lock.release()
if __name__ == "__main__":
try:
while true:
main()
time.sleep(1)
except Exception, ex:
print "Ocurred Exception: %s" % str(ex)
quit()
备注:架构图片来源于网络