Apache Curator之InterProcessMutex源码分析（四）

上篇文章通过秒购的例子对InterProcessMutex锁有了初步认识，本文将通过对源码进行分析带你进入分布式锁的世界。

老规矩先上图，为了更清晰的了解获取锁，释放锁的过程，下图简化了一些细节，使整个流程更加通畅。

下面将逐个方法去分析。

InterProcessMutex.acquire()

 

    @Override
       //获得分布式锁，阻塞
    public void acquire() throws Exception {
        if (!internalLock(-1, null)) {
            throw new IOException("Lost connection while trying to acquire lock: " + basePath);
        }
    }

       //获得分布式锁，在指定的时间内阻塞，推荐使用
    @Override
    public boolean acquire(long time, TimeUnit unit) throws Exception {
        return internalLock(time, unit);
    }

 

InterProcessMutex.internalLock(long time, TimeUnit unit)

    private boolean internalLock(long time, TimeUnit unit) throws Exception {

        Thread currentThread = Thread.currentThread();
        //获得当前线程的锁对象
        LockData lockData = threadData.get(currentThread);
        if (lockData != null) {
            // re-entering
               //如果锁不为空，当前线程已经获得锁，可重入锁，lockCount++   
            lockData.lockCount.incrementAndGet();
            return true;
        }

           //获取锁，返回锁的节点路径
        String lockPath = internals.attemptLock(time, unit, getLockNodeBytes());
        if (lockPath != null) {
               //将当前线程的锁对象信息保存起来
            LockData newLockData = new LockData(currentThread, lockPath);
            threadData.put(currentThread, newLockData);
            return true;
        }

        return false;
    }

LockInternals.attemptLock(long time, TimeUnit unit, byte[] lockNodeBytes)

    String attemptLock(long time, TimeUnit unit, byte[] lockNodeBytes) throws Exception {
        final long startMillis = System.currentTimeMillis();
        final Long millisToWait = (unit != null) ? unit.toMillis(time) : null;//等待时间，毫秒
        final byte[] localLockNodeBytes = (revocable.get() != null) ? new byte[0] : lockNodeBytes;
        int retryCount = 0;

        String ourPath = null;
        boolean hasTheLock = false;
        boolean isDone = false;
        while (!isDone) {
            isDone = true;

            try {
                   //在当前path下创建临时有序节点
                ourPath = driver.createsTheLock(client, path, localLockNodeBytes);
                   //判断是不是序号最小的节点，如果是返回true，否则阻塞等待
                hasTheLock = internalLockLoop(startMillis, millisToWait, ourPath);
            } catch (KeeperException.NoNodeException e) {
                if (client.getZookeeperClient().getRetryPolicy().allowRetry(retryCount++, System.currentTimeMillis() - startMillis, RetryLoop.getDefaultRetrySleeper())) {
                    isDone = false;
                } else {
                    throw e;
                }
            }
        }

        if (hasTheLock) {
            return ourPath;
        }

        return null;
    }

StandardLockInternalsDriver.createsTheLock(CuratorFramework client, String path, byte[] lockNodeBytes)

    @Override
    public String createsTheLock(CuratorFramework client, String path, byte[] lockNodeBytes) throws Exception {
        String ourPath;
           //在zookeeper的指定路径上，创建一个临时序列节点。只是纯粹的创建了一个节点，并不是说线程已经持有了锁。　　
        if (lockNodeBytes != null) {
            ourPath = client.create().creatingParentContainersIfNeeded().withProtection().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path, lockNodeBytes);
        } else {
            ourPath = client.create().creatingParentContainersIfNeeded().withProtection().withMode(CreateMode.EPHEMERAL_SEQUENTIAL).forPath(path);
        }
        return ourPath;
    }

LockInternals.internalLockLoop(long startMillis, Long millisToWait, String ourPath)

    private boolean internalLockLoop(long startMillis, Long millisToWait, String ourPath) throws Exception {
        boolean haveTheLock = false;
        boolean doDelete = false;
        try {
            if (revocable.get() != null) {
                client.getData().usingWatcher(revocableWatcher).forPath(ourPath);
            }

            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();
　　　　　　　　　　　　//同步，是为了实现公平锁
                    synchronized (this) {
                        try {
                               //给比自己小的节点设置监听器
                            client.getData().usingWatcher(watcher).forPath(previousSequencePath);
                            if (millisToWait != null) {
                                millisToWait -= (System.currentTimeMillis() - startMillis);
                                startMillis = System.currentTimeMillis();
                                   //等待超时，超时删除临时节点，超时时间是acquire方法传入的参数
                                if (millisToWait <= 0) {
                                    doDelete = true;    // timed out - delete our node
                                    break;
                                }
                                //没有超时，继续等待
                                wait(millisToWait);
                            } else {
                                   //如果等待时间==null，一直阻塞等待
                                wait();
                            }
                        } catch (KeeperException.NoNodeException e) {
                            // it has been deleted (i.e. lock released). Try to acquire again
                        }
                    }
                }
            }
        } catch (Exception e) {
            ThreadUtils.checkInterrupted(e);
            doDelete = true;
            throw e;
        } finally {
            if (doDelete) {
                deleteOurPath(ourPath);//如果如果抛出异常或超时，都会删除临时节点
            }
        }
        return haveTheLock;
    }

LockInternals.getSortedChildren()

    List<String> getSortedChildren() throws Exception {
        return getSortedChildren(client, basePath, lockName, driver);
    }

    public static List<String> getSortedChildren(CuratorFramework client, String basePath, final String lockName, final LockInternalsSorter sorter) throws Exception {
        try {
               //获得basePath下所有子节点，进行排序
            List<String> children = client.getChildren().forPath(basePath);
            List<String> sortedList = Lists.newArrayList(children);
            Collections.sort(sortedList, new Comparator<String>() {
                @Override
                public int compare(String lhs, String rhs) {
                    return sorter.fixForSorting(lhs, lockName).compareTo(sorter.fixForSorting(rhs, lockName));
                }
            });
            return sortedList;
        } catch (KeeperException.NoNodeException ignore) {
            return Collections.emptyList();
        }
    }

StandardLockInternalsDriver.getsTheLock(CuratorFramework c, List<String> child, String nodeName, int max)

    @Override
    public PredicateResults getsTheLock(CuratorFramework client, List<String> children, String sequenceNodeName, int maxLeases) throws Exception {
        int ourIndex = children.indexOf(sequenceNodeName);
        validateOurIndex(sequenceNodeName, ourIndex);

        boolean getsTheLock = ourIndex < maxLeases;
        String pathToWatch = getsTheLock ? null : children.get(ourIndex - maxLeases);

        return new PredicateResults(pathToWatch, getsTheLock);
    }

LockInternals.deleteOurPath(String ourPath)

    private void deleteOurPath(String ourPath) throws Exception {
        try {
            client.delete().guaranteed().forPath(ourPath);
        } catch (KeeperException.NoNodeException e) {
            // ignore - already deleted (possibly expired session, etc.)
        }
    }

InterProcessMutex.release()

    @Override
    public void release() throws Exception {
        /*
            Note on concurrency: a given lockData instance
            can be only acted on by a single thread so locking isn't necessary
         */

        Thread currentThread = Thread.currentThread();
        LockData lockData = threadData.get(currentThread);
           //如果当前线程没有持有锁，不能释放
        if (lockData == null) {
            throw new IllegalMonitorStateException("You do not own the lock: " + basePath);
        }

           //重入锁计数减一，如果还大于0，不能释放。直到所有重入业务完成，计数为0才能释放
        int newLockCount = lockData.lockCount.decrementAndGet();
        if (newLockCount > 0) {
            return;
        }
        if (newLockCount < 0) {
            throw new IllegalMonitorStateException("Lock count has gone negative for lock: " + basePath);
        }
        try {
            internals.releaseLock(lockData.lockPath);
        } finally {
            threadData.remove(currentThread);
        }
    }

LockInternals.release()

    final void releaseLock(String lockPath) throws Exception {
        client.removeWatchers();//删除监听
        revocable.set(null);
        deleteOurPath(lockPath);//删除Path
    }