处理虚假唤醒的正确方法是什么？

Question

I am reading Curator 's source code, and found some code below:

            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 
                    {
                        // use getData() instead of exists() to avoid leaving unneeded watchers which is a type of resource leak
                        client.getData().usingWatcher(watcher).forPath(previousSequencePath);
                        if ( millisToWait != null )
                        {
                            millisToWait -= (System.currentTimeMillis() - startMillis);
                            startMillis = System.currentTimeMillis();
                            if ( millisToWait <= 0 )
                            {
                                doDelete = true;    // timed out - delete our node
                                break;
                            }

                            wait(millisToWait);
                        }
                        else
                        {
                            wait();
                        }
                    }
                    catch ( KeeperException.NoNodeException e ) 
                    {
                        // it has been deleted (i.e. lock released). Try to acquire again
                    }
                }
            }
        }

I read javadoc from Object and should always check condition in loops, like this :

 synchronized (obj) {
     while (condition does not hold&)
        obj.wait(timeout);
         ... // Perform action appropriate to condition
 }

which code is right?

Update

Here is the source code of Curator .

Because haveTheLock is a local variable, no other thread would change it, so the code works fine.

Answer 1

The synchronized block is within a while loop.

And it has two branches:

• an infinite wait() : no condition to check
• a timed wait(millisToWait) and the amount of millis to wait is recalculated at each loop

So spurious wakeups won't really have an effect. The main reason to have the while loop inside the synchronized block as in the javadoc is that very often you need the synchronization to make sure the result of the condition is visible.

In the code you show, I means that both client.getState() and haveTheLock should be thread safe (for example volatile variables).