code: @GuardedBy("lock")
    private void signalNextWaiter() {
      for (Guard guard = activeGuards; guard != null; guard = guard.next) {
        if (isSatisfied(guard)) {
          guard.condition.signal();
          break;
        }
      }
    }
docs: 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.