android/guava/src/com/google/common/util/concurrent/Monitor.java
@GuardedBy("lock")
  private void signalNextWaiter() {
    for (Guard guard = activeGuards; guard != null; guard = guard.next) {
      if (isSatisfied(guard)) {
        guard.condition.signal();
        break;
      }
    }
  }
@GuardedBy("lock")
  private void signalNextWaiter() {
    for (Guard guard = activeGuards; guard != null; guard = guard.next) {
      if (isSatisfied(guard)) {
        guard.condition.signal();
        break;
      }
    }
  }
Signals some other thread waiting on a satisfied guard, if one exists.

<p>We manage calls to this method carefully, to signal only when necessary, but never losing a
signal, which is the classic problem of this kind of concurrency construct. We must signal if
the current thread is about to relinquish the lock and may have changed the state protected by
the monitor, thereby causing some guard to be satisfied.

<p>In addition, any thread that has been signalled when its guard was satisfied acquires the
responsibility of signalling the next thread when it again relinquishes the lock. Unlike a
normal Condition, there is no guarantee that an interrupted thread has not been signalled,
since the concurrency control must manage multiple Conditions. So this method must generally be
called when waits are interrupted.

<p>On the other hand, if a signalled thread wakes up to discover that its guard is still not
satisfied, it does *not* need to call this method before returning to wait. This can only
happen due to spurious wakeup (ignorable) or another thread acquiring the lock before the
current thread can and returning the guard to the unsatisfied state. In the latter case the
other thread (last thread modifying the state protected by the monitor) takes over the
responsibility of signalling the next waiter.

<p>This method must not be called from within a beginWaitingFor/endWaitingFor block, or else
the current thread's guard might be mistakenly signalled, leading to a lost signal.