zookeeper学习笔记---分布式锁

1：分布式锁

• 分布式锁主要用于在分布式环境中保护跨进程、跨主机、跨网络的共享资源实现互斥访问，以达到保证数据一致性。

2：概念介绍

• 持久节点（PERSISTENT）

所谓持久节点，是指在节点创建后，就一直存在，直到有删除操作来主动清除这个节点——不会因为创建该节点的客户端会话失效而消失。

• 持久顺序节点（PERSISTENT_SEQUENTIAL）

这类节点的基本特性和上面的节点类型是一致的。额外的特性是，在ZK中，每个父节点会为他的第一级子节点维护一份时序，会记录每个子节点创建的先后顺序。基于这个特性，在创建子节点的时候，可以设置这个属性，那么在创建节点过程中，ZK会自动为给定节点名加上一个数字后缀，作为新的节点名。这个数字后缀的范围是整型的最大值。

• 临时节点（EPHEMERAL）

和持久节点不同的是，临时节点的生命周期和客户端会话绑定。也就是说，如果客户端会话失效，那么这个节点就会自动被清除掉。注意，这里提到的是会话失效，而非连接断开。另外，在临时节点下面不能创建子节点。

• 临时顺序节点（EPHEMERAL_SEQUENTIAL）

临时节点的生命周期和客户端会话绑定，并且会有一个时序编号（如0000000001）。可以用来实现分布式锁

3：架构图

 

4：分布式锁实现思路

1. 首先在ZK上创建持久节点（如locker），然后在持久节点（locker）下创建临时顺序节点。（释放锁时记得删除该临时顺序节点）
2. 获取持久节点下所有的临时顺序节点，然后按其节点序号对其进行从小到大排序，判断自己的节点序号是不是最小的，如果是则获得锁。
3. 如果不是，对自己节点序号前一个节点序号的临时顺序进行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()

 备注：架构图片来源于网络