Method doJoin

src/Deferred.java:1112–1201

Synchronously waits until this Deferred is called back. @param interruptible Whether or not to let InterruptedException interrupt us. If false then this method will never throw InterruptedException, it will handle it and keep waiting. In this case though, the interrupted st

(final boolean interruptible, final long timeout)

   * @throws TimeoutException if there's a timeout.
   */
  @SuppressWarnings("unchecked")
  private T doJoin(final boolean interruptible, final long timeout)
  throws InterruptedException, Exception {
    if (state == DONE) {  // Nothing to join, we're already DONE.
      if (result instanceof Exception) {
        throw (Exception) result;
      }
      return (T) result;
    }

    final Signal signal_cb = new Signal();

    // Dealing with InterruptedException properly is a PITA.  I highly
    // recommend reading http://goo.gl/aeOOXT to understand how this works.
    boolean interrupted = false;
    try {
      while (true) {
        try {
          boolean timedout = false;
          synchronized (signal_cb) {
            addBoth((Callback<T, T>) ((Object) signal_cb));
            if (timeout == 0) {  // No timeout, we can use a simple loop.
              // If we get called back immediately, we won't enter the loop.
              while (signal_cb.result == signal_cb) {
                signal_cb.wait();
              }
            } else if (timeout < 0) {
              throw new IllegalArgumentException("negative timeout: " + timeout);
            } else {  // We have a timeout, the loop is a bit more complicated.
              long timeleft = timeout * 1000000L;  // Convert to nanoseconds.
              if (timeout > 31556926000L) {  // One year in milliseconds.
                // Most likely a programming bug.
                LOG.warn("Timeout (" + timeout + ") is long than 1 year."
                         + "  this=" + this);
                if (timeleft <= 0) {  // Very unlikely.
                  throw new IllegalArgumentException("timeout overflow after"
                    + " conversion to nanoseconds: " + timeout);
                }
              }
              // If we get called back immediately, we won't enter the loop.
              while (signal_cb.result == signal_cb) {
                // We can't distinguish between a timeout and a spurious wakeup.
                // So we have to time how long we slept to figure out whether we
                // timed out or how long we need to sleep again.  There's no
                // better way to do this, that's how it's implemented in the JDK
                // in `AbstractQueuedSynchronizer.ConditionObject.awaitNanos()'.
                long duration = System.nanoTime();
                final long millis = timeleft / 1000000L;
                final int nanos = (int) (timeleft % 1000000);
                // This API is annoying because it won't let us specify just
                // nanoseconds.  The second argument must be less than 1000000.
                signal_cb.wait(millis, nanos);
                duration = System.nanoTime() - duration;
                timeleft -= duration;
                // If we have 0ns or less left, the timeout has expired
                // already.  If we have less than 100ns left, there's no
                // point in looping again, as just going through the loop
                // above easily takes 100ns on a modern x86-64 CPU, after