实现分布式锁目前有三种流行方案，分别为基于数据库、Redis、Zookeeper的方案，其中前两种方案网络上有很多资料可以参考，本文不做展开。我们来看下使用Zookeeper如何实现分布式锁。

什么是zookeeper

Zookeeper(业界简称zk)是一种提供配置管理、分布式协同以及命名的中心化服务，这些提供的功能都是分布式系统中非常底层且必不可少的基本功能，但是如果自己实现这些功能而且要达到高吞吐、低延迟同时还要保持一致性和可用性，实际上非常困难。因此zookeeper提供了这些功能，开发者在zookeeper之上构建自己的各种分布式系统。

虽然zookeeper的实现比较复杂，但是它提供的模型抽象却是非常简单的。Zookeeper提供一个多层级的节点命名空间(节点称为znode)，每个节点都用一个以斜杠(/)分隔的路径表示，而且每个节点都有父节点(根节点除外)，非常类似于文件系统。例如，/foo/doo这个表示一个znode，它的父节点为/foo，父父节点为/，而/为根节点没有父节点。与文件系统不同的是，这些节点都可以设置关联的数据，而文件系统中只有文件节点可以存放数据而目录节点不行。Zookeeper为了保证高吞吐和低延迟，在内存中维护了这个树状的目录结构，这种特性使得Zookeeper不能用于存放大量的数据，每个节点的存放数据上限为1M。

而为了保证高可用，zookeeper需要以集群形态来部署，这样只要集群中大部分机器是可用的(能够容忍一定的机器故障)，那么zookeeper本身仍然是可用的。客户端在使用zookeeper时，需要知道集群机器列表，通过与集群中的某一台机器建立TCP连接来使用服务，客户端使用这个TCP链接来发送请求、获取结果、获取监听事件以及发送心跳包。如果这个连接异常断开了，客户端可以连接到另外的机器上。

客户端的读请求可以被集群中的任意一台机器处理，如果读请求在节点上注册了监听器，这个监听器也是由所连接的zookeeper机器来处理。对于写请求，这些请求会同时发给其他zookeeper机器并且达成一致后，请求才会返回成功。因此，随着zookeeper的集群机器增多，读请求的吞吐会提高但是写请求的吞吐会下降。

有序性是zookeeper中非常重要的一个特性，所有的更新都是全局有序的，每个更新都有一个唯一的时间戳，这个时间戳称为zxid(Zookeeper Transaction Id)。而读请求只会相对于更新有序，也就是读请求的返回结果中会带有这个zookeeper***的zxid。

Zookeeper节点的概念

zookeeper节点示意图.png

Znode分为四种类型：

1.持久节点（PERSISTENT）

默认的节点类型。创建节点的客户端与zookeeper断开连接后，该节点依旧存在。

2.持久节点顺序节点（PERSISTENT_SEQUENTIAL）

所谓顺序节点，就是在创建节点时，Zookeeper根据创建的时间顺序给该节点名称进行编号：

持久顺序节点.png

3.临时节点（EPHEMERAL）

和持久节点相反，当创建节点的客户端与zookeeper断开连接后，临时节点会被删除：

4.临时顺序节点（EPHEMERAL_SEQUENTIAL）

顾名思义，临时顺序节点结合和临时节点和顺序节点的特点：在创建节点时，Zookeeper根据创建的时间顺序给该节点名称进行编号；当创建节点的客户端与zookeeper断开连接后，临时节点会被删除。

Zookeeper分布式锁的实现原理

Zookeeper分布式锁恰恰应用了临时顺序节点。

获取锁

首先，在Zookeeper当中创建一个持久节点ParentLock。当第一个客户端想要获得锁时，需要在ParentLock这个节点下面创建一个临时顺序节点 Lock1。

Client1尝试获取锁.png

之后，Client1查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock1是不是顺序最靠前的一个。如果是第一个节点，则成功获得锁。

Client1获得锁.png

这时候，如果再有一个客户端 Client2 前来获取锁，则在ParentLock下载再创建一个临时顺序节点Lock2。

Client2查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock2是不是顺序最靠前的一个，结果发现节点Lock2并不是最小的。
于是，Client2向排序仅比它靠前的节点Lock1注册Watcher，用于监听Lock1节点是否存在。这意味着Client2抢锁失败，进入了等待状态。

这时候，如果又有一个客户端Client3前来获取锁，则在ParentLock下载再创建一个临时顺序节点Lock3。

Client3查找ParentLock下面所有的临时顺序节点并排序，判断自己所创建的节点Lock3是不是顺序最靠前的一个，结果同样发现节点Lock3并不是最小的。
于是，Client3向排序仅比它靠前的节点Lock2注册Watcher，用于监听Lock2节点是否存在。这意味着Client3同样抢锁失败，进入了等待状态。

这样一来，Client1得到了锁，Client2监听了Lock1，Client3监听了Lock2。这恰恰形成了一个等待队列，很像是Java当中ReentrantLock所依赖的

释放锁

释放锁分为两种情况：

1.任务完成，客户端显示释放

当任务完成时，Client1会显示调用删除节点Lock1的指令。

2.任务执行过程中，客户端崩溃

获得锁的Client1在任务执行过程中，如果Duang的一声崩溃，则会断开与Zookeeper服务端的链接。根据临时节点的特性，相关联的节点Lock1会随之自动删除。

由于Client2一直监听着Lock1的存在状态，当Lock1节点被删除，Client2会立刻收到通知。这时候Client2会再次查询ParentLock下面的所有节点，确认自己创建的节点Lock2是不是目前最小的节点。如果是最小，则Client2顺理成章获得了锁。

同理，如果Client2也因为任务完成或者节点崩溃而删除了节点Lock2，那么Client3就会接到通知。
最终，Client3成功得到了锁。

Curator框架实现Zookeeper分布式锁

虽然zookeeper原生客户端暴露的API已经非常简洁了，但是实现一个分布式锁还是比较麻烦的…我们可以直接使用 curator 这个开源项目提供的zookeeper分布式锁实现。

导入第三方框架curator-recipes 的jar包

<dependency> 
    <groupId>org.apache.curator</groupId> 
    <artifactId>curator-recipes</artifactId> 
    <version>4.0.0</version> 
</dependency>

代码实现

public static void main(String[] args) throws Exception { 
    //创建zookeeper的客户端 
    RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3); 
    CuratorFramework client = CuratorFrameworkFactory.newClient("10.21.41.181:2181,10.21.42.47:2181,10.21.49.252:2181", retryPolicy); 
    client.start(); 
 
    //创建分布式锁, 锁空间的根节点路径为/curator/lock 
    InterProcessMutex mutex = new InterProcessMutex(client, "/curator/lock"); 
    mutex.acquire(); 
    //获得了锁, 进行业务流程 
    System.out.println("Enter mutex"); 
    //完成业务流程, 释放锁 
    mutex.release(); 
     
    //关闭客户端 
    client.close(); 
}

可以看到关键的核心操作就只有mutex.acquire()和mutex.release()，简直太方便了!
下面来分析下获取锁的源码实现。acquire的方法如下：

/* 
 * 获取锁，当锁被占用时会阻塞等待，这个操作支持同线程的可重入（也就是重复获取锁），acquire的次数需要与release的次数相同。 
 * @throws Exception ZK errors, connection interruptions 
 */ 
@Override 
public void acquire() throws Exception 
{ 
    if ( !internalLock(-1, null) ) 
    { 
        throw new IOException("Lost connection while trying to acquire lock: " + basePath); 
    } 
}

这里有个地方需要注意，当与zookeeper通信存在异常时，acquire会直接抛出异常，需要使用者自身做重试策略。代码中调用了internalLock(-1, null)，参数表明在锁被占用时***阻塞等待。internalLock的代码如下：

private boolean internalLock(long time, TimeUnit unit) throws Exception 
{ 
 
    //这里处理同线程的可重入性，如果已经获得锁，那么只是在对应的数据结构中增加acquire的次数统计，直接返回成功 
    Thread currentThread = Thread.currentThread(); 
    LockData lockData = threadData.get(currentThread); 
    if ( lockData != null ) 
    { 
        // re-entering 
        lockData.lockCount.incrementAndGet(); 
        return true; 
    } 
 
    //这里才真正去zookeeper中获取锁 
    String lockPath = internals.attemptLock(time, unit, getLockNodeBytes()); 
    if ( lockPath != null ) 
    { 
        //获得锁之后，记录当前的线程获得锁的信息，在重入时只需在LockData中增加次数统计即可 
        LockData newLockData = new LockData(currentThread, lockPath); 
        threadData.put(currentThread, newLockData); 
        return true; 
    } 
 
    //在阻塞返回时仍然获取不到锁，这里上下文的处理隐含的意思为zookeeper通信异常 
    return false; 
}

看下zookeeper获取锁的具体实现：

String attemptLock(long time, TimeUnit unit, byte[] lockNodeBytes) throws Exception 
{ 
    //参数初始化，此处省略 
    //... 
    
    //自旋获取锁 
    while ( !isDone ) 
    { 
        isDone = true; 
 
        try 
        { 
            //在锁空间下创建临时且有序的子节点 
            ourPath = driver.createsTheLock(client, path, localLockNodeBytes); 
            //判断是否获得锁（子节点序号最小），获得锁则直接返回，否则阻塞等待前一个子节点删除通知 
            hasTheLock = internalLockLoop(startMillis, millisToWait, ourPath); 
        } 
        catch ( KeeperException.NoNodeException e ) 
        { 
            //对于NoNodeException，代码中确保了只有发生session过期才会在这里抛出NoNodeException，因此这里根据重试策略进行重试 
            if ( client.getZookeeperClient().getRetryPolicy().allowRetry(retryCount++, System.currentTimeMillis() - startMillis, RetryLoop.getDefaultRetrySleeper()) ) 
            { 
                isDone = false; 
            } 
            else 
            { 
                throw e; 
            } 
        } 
    } 
 
    //如果获得锁则返回该子节点的路径 
    if ( hasTheLock ) 
    { 
        return ourPath; 
    } 
 
    return null; 
}

上面代码中主要有两步操作：

driver.createsTheLock：创建临时且有序的子节点，里面实现比较简单不做展开，主要关注几种节点的模式：

PERSISTENT(持久节点);
PERSISTENT_SEQUENTIAL(持久且有序);
EPHEMERAL(临时);
EPHEMERAL_SEQUENTIAL(临时且有序)。

internalLockLoop：阻塞等待直到获得锁。
看下internalLockLoop是怎么判断锁以及阻塞等待的，这里删除了一些无关代码，只保留主流程：

//自旋直至获得锁 
while ( (client.getState() == CuratorFrameworkState.STARTED) && !haveTheLock ) 
{ 
    //获取所有的子节点列表，并且按序号从小到大排序 
    List<String>        children = getSortedChildren(); 
     
    //根据序号判断当前子节点是否为最小子节点 
    String              sequenceNodeName = ourPath.substring(basePath.length() + 1); // +1 to include the slash 
    PredicateResults    predicateResults = driver.getsTheLock(client, children, sequenceNodeName, maxLeases); 
    if ( predicateResults.getsTheLock() ) 
    { 
        //如果为最小子节点则认为获得锁 
        haveTheLock = true; 
    } 
    else 
    { 
        //否则获取前一个子节点 
        String  previousSequencePath = basePath + "/" + predicateResults.getPathToWatch(); 
 
        //这里使用对象监视器做线程同步，当获取不到锁时监听前一个子节点删除消息并且进行wait()，当前一个子节点删除（也就是锁释放）时，回调会通过notifyAll唤醒此线程，此线程继续自旋判断是否获得锁 
        synchronized(this) 
        { 
            try  
            { 
                //这里使用getData()接口而不是checkExists()是因为，如果前一个子节点已经被删除了那么会抛出异常而且不会设置事件监听器，而checkExists虽然也可以获取到节点是否存在的信息但是同时设置了监听器，这个监听器其实永远不会触发，对于zookeeper来说属于资源泄露 
                client.getData().usingWatcher(watcher).forPath(previousSequencePath); 
 
                //如果设置了阻塞等待的时间 
                if ( millisToWait != null ) 
                { 
                    millisToWait -= (System.currentTimeMillis() - startMillis); 
                    startMillis = System.currentTimeMillis(); 
                    if ( millisToWait <= 0 ) 
                    { 
                        doDelete = true;    // 等待时间到达，删除对应的子节点 
                        break; 
                    } 
                     
                    //等待相应的时间 
                    wait(millisToWait); 
                } 
                else 
                { 
                   //永远等待 
                    wait(); 
                } 
            } 
            catch ( KeeperException.NoNodeException e )  
            { 
                //上面使用getData来设置监听器时，如果前一个子节点已经被删除那么会抛出NoNodeException，只需要自旋一次即可，无需额外处理 
            } 
        } 
    } 
}

代码中设置的事件监听器，在事件发生回调时只是简单的notifyAll唤醒当前线程以重新自旋判断。

缺点：

性能上可能并没有缓存服务那么高。因为每次在创建锁和释放锁的过程中，都要动态创建、销毁瞬时节点来实现锁功能。ZK中创建和删除节点只能通过Leader服务器来执行，然后将数据同步到所有的Follower机器上。

其实，使用Zookeeper也有可能带来并发问题，只是并不常见而已。考虑这样的情况，由于网络抖动，客户端可ZK集群的session连接断了，那么zk以为客户端挂了，就会删除临时节点，这时候其他客户端就可以获取到分布式锁了。就可能产生并发问题。这个问题不常见是因为zk有重试机制，一旦zk集群检测不到客户端的心跳，就会重试，Curator客户端支持多种重试策略。多次重试之后还不行的话才会删除临时节点。（所以，选择一个合适的重试策略也比较重要，要在锁的粒度和并发之间找一个平衡。）

基于Zookeeper的分布式锁🔒

基于Zookeeper的分布式锁🔒

什么是zookeeper

Zookeeper节点的概念

1.持久节点（PERSISTENT）

2.持久节点顺序节点（PERSISTENT_SEQUENTIAL）

3.临时节点（EPHEMERAL）

4.临时顺序节点（EPHEMERAL_SEQUENTIAL）

Zookeeper分布式锁的实现原理

获取锁

释放锁

1.任务完成，客户端显示释放

2.任务执行过程中，客户端崩溃

Curator框架实现Zookeeper分布式锁

导入第三方框架curator-recipes 的jar包

代码实现

缺点：

基于Zookeeper的分布式锁🔒

什么是zookeeper

Zookeeper节点的概念

1.持久节点 （PERSISTENT）

2.持久节点顺序节点（PERSISTENT_SEQUENTIAL）

3.临时节点（EPHEMERAL）

4.临时顺序节点（EPHEMERAL_SEQUENTIAL）

Zookeeper分布式锁的实现原理

获取锁

释放锁

1.任务完成，客户端显示释放

2.任务执行过程中，客户端崩溃

Curator框架实现Zookeeper分布式锁

导入第三方框架curator-recipes 的jar包

代码实现

缺点：

1.持久节点（PERSISTENT）