public static void waitForRehashToComplete(Cache... caches) {
   // give it 1 second to start rehashing
   // TODO Should look at the last committed view instead and check if it contains all the caches
   LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
   int gracetime = 30000; // 30 seconds?
   long giveup = System.currentTimeMillis() + gracetime;
   for (Cache c : caches) {
     CacheViewsManager cacheViewsManager =
         TestingUtil.extractGlobalComponent(c.getCacheManager(), CacheViewsManager.class);
     RpcManager rpcManager = TestingUtil.extractComponent(c, RpcManager.class);
     while (cacheViewsManager.getCommittedView(c.getName()).getMembers().size() != caches.length) {
       if (System.currentTimeMillis() > giveup) {
         String message =
             String.format(
                 "Timed out waiting for rehash to complete on node %s, expected member list is %s, current member list is %s!",
                 rpcManager.getAddress(),
                 Arrays.toString(caches),
                 cacheViewsManager.getCommittedView(c.getName()));
         log.error(message);
         throw new RuntimeException(message);
       }
       LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
     }
     log.trace("Node " + rpcManager.getAddress() + " finished rehash task.");
   }
 }
  @Override
  public final V get(final long timeout, final TimeUnit unit)
      throws InterruptedException, ExecutionException, TimeoutException {
    Object response = registerWaiter(Thread.currentThread(), null);
    if (response != VOID) {
      return resolveAndThrow(response);
    }

    long deadlineNanos = System.nanoTime() + unit.toNanos(timeout);
    boolean interrupted = false;
    try {
      long timeoutNanos = unit.toNanos(timeout);
      while (timeoutNanos > 0) {
        parkNanos(timeoutNanos);
        timeoutNanos = deadlineNanos - System.nanoTime();

        if (isDone()) {
          return resolveAndThrow(state);
        } else if (Thread.interrupted()) {
          interrupted = true;
          onInterruptDetected();
        }
      }
    } finally {
      restoreInterrupt(interrupted);
    }

    unregisterWaiter(Thread.currentThread());
    throw newTimeoutException(timeout, unit);
  }
示例#3
0
  public void await() {

    long spin = 1;
    while (!done) {
      LockSupport.parkNanos(spin++);
    }
  }
  /** @see Sequencer#next(int) */
  @Override
  public long next(int n) {
    if (n < 1) {
      throw new IllegalArgumentException("n must be > 0");
    }

    long nextValue = this.nextValue;

    long nextSequence = nextValue + n;
    long wrapPoint = nextSequence - bufferSize;
    long cachedGatingSequence = this.cachedValue;

    if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue) {
      long minSequence;
      while (wrapPoint > (minSequence = Sequencer.getMinimumSequence(gatingSequences, nextValue))) {
        if (spinObserver != null) {
          spinObserver.accept(null);
        }
        LockSupport.parkNanos(1L); // TODO: Use waitStrategy to spin?
      }

      this.cachedValue = minSequence;
    }

    this.nextValue = nextSequence;

    return nextSequence;
  }
  @Override
  public void generate(int level) {
    File file = new File("outputfile");
    while (true) {

      for (long i = 0; i < 1000 * level; i++) {

        try {

          BufferedWriter writer = new BufferedWriter(new FileWriter(file));
          for (long j = 0; j < 1000; j++) writer.write("1234567890qwertyuiopasdfghjklzxcvbvnm");
          writer.close();

          Scanner scanner = new Scanner(new FileReader(file));
          while (scanner.hasNextLine()) scanner.nextLine();
          scanner.close();

        } catch (IOException e) {
          System.out.println("I/O error");
          file.delete();
        }
      }

      workUnits.getAndIncrement();

      java.util.concurrent.locks.LockSupport.parkNanos(1);
    }
  }
 @Test
 public void testTransactionAtomicity_whenMultiMapGetIsUsed_withTransaction()
     throws InterruptedException {
   final HazelcastInstance hz = Hazelcast.newHazelcastInstance(createConfigWithDummyTxService());
   final String name = HazelcastTestSupport.generateRandomString(5);
   Thread producerThread = startProducerThread(hz, name);
   try {
     IQueue<String> q = hz.getQueue(name);
     for (int i = 0; i < 1000; i++) {
       String id = q.poll();
       if (id != null) {
         TransactionContext tx = hz.newTransactionContext();
         try {
           tx.beginTransaction();
           TransactionalMultiMap<Object, Object> multiMap = tx.getMultiMap(name);
           Collection<Object> values = multiMap.get(id);
           assertFalse(values.isEmpty());
           multiMap.remove(id);
           tx.commitTransaction();
         } catch (TransactionException e) {
           tx.rollbackTransaction();
           e.printStackTrace();
         }
       } else {
         LockSupport.parkNanos(100);
       }
     }
   } finally {
     stopProducerThread(producerThread);
   }
 }
示例#7
0
 @Override
 public boolean offer(WaitStrategy.Offerable o) throws InterruptedException {
   while (!o.offer()) {
     LockSupport.parkNanos(1l);
   }
   return true;
 }
示例#8
0
  /**
   * Spins/yields/blocks until node s is matched or caller gives up.
   *
   * @param s the waiting node
   * @param pred the predecessor of s, or s itself if it has no predecessor, or null if unknown (the
   *     null case does not occur in any current calls but may in possible future extensions)
   * @param e the comparison value for checking match
   * @param timed if true, wait only until timeout elapses
   * @param nanos timeout in nanosecs, used only if timed is true
   * @return matched item, or e if unmatched on interrupt or timeout
   */
  private E awaitMatch(Node s, Node pred, E e, boolean timed, long nanos) {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    Thread w = Thread.currentThread();
    int spins = -1; // initialized after first item and cancel checks
    ThreadLocalRandom randomYields = null; // bound if needed

    for (; ; ) {
      Object item = s.item;
      if (item != e) { // matched
        // assert item != s;
        s.forgetContents(); // avoid garbage
        return LinkedTransferQueue.<E>cast(item);
      }
      if ((w.isInterrupted() || (timed && nanos <= 0)) && s.casItem(e, FORGOTTEN)) { // cancel
        unsplice(pred, s);
        return e;
      }

      if (spins < 0) { // establish spins at/near front
        if ((spins = spinsFor(pred, s.isData)) > 0) randomYields = ThreadLocalRandom.current();
      } else if (spins > 0) { // spin
        --spins;
        if (randomYields.nextInt(CHAINED_SPINS) == 0) Thread.yield(); // occasionally yield
      } else if (s.waiter == null) {
        s.waiter = w; // request unpark then recheck
      } else if (timed) {
        nanos = deadline - System.nanoTime();
        if (nanos > 0L) LockSupport.parkNanos(this, nanos);
      } else {
        LockSupport.park(this);
      }
    }
  }
示例#9
0
    private boolean sendMessages(
        RingBuffer<byte[]> ringBuffer, long messagesPerSecond, int runtimeSeconds)
        throws InterruptedException {
      LOGGER.info("Rate: " + messagesPerSecond + ", for " + runtimeSeconds + "s");

      long runtimeNanos = TimeUnit.SECONDS.toNanos(runtimeSeconds);

      long t0 = System.nanoTime();
      long delta = 0;
      long sent = 0;

      try {
        do {
          delta = System.nanoTime() - t0;
          long shouldHaveSent = (messagesPerSecond * delta) / 1000000000;

          for (; sent < shouldHaveSent; sent++) {
            if (!send(ringBuffer)) {
              return false;
            }
          }

          LockSupport.parkNanos(1);
        } while (delta <= runtimeNanos);

        Thread.sleep(1000);
        return ringBuffer.hasAvailableCapacity(ringBuffer.getBufferSize());

      } finally {
        while (!ringBuffer.hasAvailableCapacity(ringBuffer.getBufferSize())) {
          Thread.sleep(1000);
        }
      }
    }
示例#10
0
 // 处理无数据的情况,避免空循环挂死
 private void applyWait(int fullTimes) {
   int newFullTimes = fullTimes > maxFullTimes ? maxFullTimes : fullTimes;
   if (fullTimes <= 3) { // 3次以内
     Thread.yield();
   } else { // 超过3次,最多只sleep 10ms
     LockSupport.parkNanos(1000 * 1000L * newFullTimes);
   }
 }
 protected void pause(int delayNS) {
   if (delayNS < 1) return;
   long start = System.nanoTime();
   if (delayNS >= 1000 * 1000) LockSupport.parkNanos(delayNS - 1000 * 1000); // only ms accuracy.
   while (System.nanoTime() - start < delayNS) {
     Thread.yield();
   }
 }
 @Override
 public int idle(final int idleCounter) {
   if (idleCounter > 200) {
     LockSupport.parkNanos(1L);
   } else if (idleCounter > 100) {
     Thread.yield();
   }
   return idleCounter + 1;
 }
示例#13
0
  @Override
  public T take(WaitStrategy.Takeable<T> t) throws InterruptedException {
    T result;

    while ((result = t.take()) == null) {
      LockSupport.parkNanos(1l);
    }

    return result;
  }
示例#14
0
  /**
   * Join which can be called exactly once!
   *
   * @return Result
   */
  public T join() {

    try {
      long spin = 1;
      while (!done) {
        LockSupport.parkNanos(spin++);
      }
      if (completedExceptionally) throw (new SimpleReactCompletionException(exception()));
      return result();
    } finally {
      markComplete();
    }
  }
 public static void waitForRehashToComplete(Cache cache, int groupSize) {
   LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
   int gracetime = 30000; // 30 seconds?
   long giveup = System.currentTimeMillis() + gracetime;
   CacheViewsManager cacheViewsManager =
       TestingUtil.extractGlobalComponent(cache.getCacheManager(), CacheViewsManager.class);
   RpcManager rpcManager = TestingUtil.extractComponent(cache, RpcManager.class);
   while (cacheViewsManager.getCommittedView(cache.getName()).getMembers().size() != groupSize) {
     if (System.currentTimeMillis() > giveup) {
       String message =
           String.format(
               "Timed out waiting for rehash to complete on node %s, expected member count %s, current member count is %s!",
               rpcManager.getAddress(),
               groupSize,
               cacheViewsManager.getCommittedView(cache.getName()));
       log.error(message);
       throw new RuntimeException(message);
     }
     LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
   }
   log.trace("Node " + rpcManager.getAddress() + " finished rehash task.");
 }
    public long waitOnLock(
        final long sequence,
        Sequence cursorSequence,
        final Sequence dependentSequence,
        final SequenceBarrier barrier)
        throws AlertException, InterruptedException {
      long availableSequence;

      while ((availableSequence = dependentSequence.get()) < sequence) {
        LockSupport.parkNanos(1);
      }

      return availableSequence;
    }
  @Override
  public long waitForNext() {
    // set random interval on the first run
    if (nextNanos == 0) {
      nextNanos = nanoTime() + nextLong(0, intervalNanos);
    }

    long delayNanos = nextNanos - nanoTime();
    if (delayNanos > 0) {
      parkNanos(delayNanos);
    }

    long expectedStartNanos = nextNanos;
    nextNanos += intervalNanos;
    return accountForCoordinatedOmission ? expectedStartNanos : nanoTime();
  }
示例#18
0
 /**
  * Spins/blocks until node s is matched by a fulfill operation.
  *
  * @param s the waiting node
  * @param timed true if timed wait
  * @param nanos timeout value
  * @return matched node, or s if cancelled
  */
 SNode awaitFulfill(SNode s, boolean timed, long nanos) {
   /*
    * When a node/thread is about to block, it sets its waiter
    * field and then rechecks state at least one more time
    * before actually parking, thus covering race vs
    * fulfiller noticing that waiter is non-null so should be
    * woken.
    *
    * When invoked by nodes that appear at the point of call
    * to be at the head of the stack, calls to park are
    * preceded by spins to avoid blocking when producers and
    * consumers are arriving very close in time.  This can
    * happen enough to bother only on multiprocessors.
    *
    * The order of checks for returning out of main loop
    * reflects fact that interrupts have precedence over
    * normal returns, which have precedence over
    * timeouts. (So, on timeout, one last check for match is
    * done before giving up.) Except that calls from untimed
    * SynchronousQueue.{poll/offer} don't check interrupts
    * and don't wait at all, so are trapped in transfer
    * method rather than calling awaitFulfill.
    */
   long lastTime = timed ? System.nanoTime() : 0;
   Thread w = Thread.currentThread();
   SNode h = head;
   int spins = (shouldSpin(s) ? (timed ? maxTimedSpins : maxUntimedSpins) : 0);
   for (; ; ) {
     if (w.isInterrupted()) s.tryCancel();
     SNode m = s.match;
     if (m != null) return m;
     if (timed) {
       long now = System.nanoTime();
       nanos -= now - lastTime;
       lastTime = now;
       if (nanos <= 0) {
         s.tryCancel();
         continue;
       }
     }
     if (spins > 0) spins = shouldSpin(s) ? (spins - 1) : 0;
     else if (s.waiter == null) s.waiter = w; // establish waiter so can park next iter
     else if (!timed) LockSupport.park(this);
     else if (nanos > spinForTimeoutThreshold) LockSupport.parkNanos(this, nanos);
   }
 }
示例#19
0
    protected long await(long nanoSeconds) throws InterruptedException {
      long target_nano = System.nanoTime() + nanoSeconds;

      if (!signaled.get()) {
        // We release the lock at the same time as waiting on the
        // condition
        lock.acquired = false;
        sendAwaitConditionRequest(lock.name, lock.owner);

        boolean interrupted = false;
        while (!signaled.get()) {
          long wait_nano = target_nano - System.nanoTime();
          // If we waited max time break out
          if (wait_nano > 0) {
            parker.set(Thread.currentThread());
            LockSupport.parkNanos(this, wait_nano);

            if (Thread.interrupted()) {
              // If we were interrupted and haven't received a response yet then we try to
              // clean up the lock request and throw the exception
              if (!signaled.get()) {
                sendDeleteAwaitConditionRequest(lock.name, lock.owner);
                throw new InterruptedException();
              }
              // In the case that we were signaled and interrupted
              // we want to return the signal but still interrupt
              // our thread
              interrupted = true;
            }
          } else {
            break;
          }
        }
        if (interrupted) Thread.currentThread().interrupt();
      }

      // We set as if this signal was no released.  This way if the
      // condition is reused again, but the client condition isn't lost
      // we won't think we were signaled immediately
      // If we weren't signaled then delete our request
      if (!signaled.getAndSet(false)) {
        sendDeleteAwaitConditionRequest(lock.name, lock.owner);
      }
      return target_nano - System.nanoTime();
    }
 /**
  * @deprecated Should use {@link #waitForRehashToComplete(org.infinispan.Cache[])} instead, this
  *     is not reliable with merges
  */
 public static void waitForInitRehashToComplete(Cache... caches) {
   int gracetime = 30000; // 30 seconds?
   long giveup = System.currentTimeMillis() + gracetime;
   for (Cache c : caches) {
     StateTransferManager stateTransferManager =
         TestingUtil.extractComponent(c, StateTransferManager.class);
     RpcManager rpcManager = TestingUtil.extractComponent(c, RpcManager.class);
     while (!stateTransferManager.isJoinComplete()) {
       if (System.currentTimeMillis() > giveup) {
         String message =
             "Timed out waiting for join to complete on node " + rpcManager.getAddress() + " !";
         log.error(message);
         throw new RuntimeException(message);
       }
       LockSupport.parkNanos(TimeUnit.MILLISECONDS.toNanos(100));
     }
     log.trace("Node " + rpcManager.getAddress() + " finished join task.");
   }
 }
示例#21
0
 public static void waitForRehashToComplete(Cache... caches) {
   int gracetime = 30000; // 30 seconds?
   long giveup = System.currentTimeMillis() + gracetime;
   for (Cache c : caches) {
     DistributionManagerImpl dmi =
         (DistributionManagerImpl) TestingUtil.extractComponent(c, DistributionManager.class);
     while (dmi.isRehashInProgress()) {
       if (System.currentTimeMillis() > giveup) {
         String message =
             "Timed out waiting for rehash to complete on node "
                 + dmi.getRpcManager().getAddress()
                 + " !";
         log.error(message);
         throw new RuntimeException(message);
       }
       LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
     }
     log.trace("Node " + dmi.getRpcManager().getAddress() + " finished rehash task.");
   }
 }
示例#22
0
    public void run() {
      while (_isRunnable) {
        if (_quantumCount >= _timeout) {
          _quantumCount = 0;

          try {
            ArrayList<Env> activeEnv = new ArrayList<Env>(_activeEnvSet.keySet());

            for (Env env : activeEnv) {
              env.updateTimeout();
            }

          } catch (Throwable e) {
          }
        } else {
          _quantumCount += ENV_TIMEOUT_UPDATE_INTERVAL;
        }

        LockSupport.parkNanos(ENV_TIMEOUT_UPDATE_INTERVAL * 1000000L);
      }
    }
 @Test
 public void testTransactionAtomicity_whenMultiMapValueCountIsUsed_withoutTransaction()
     throws InterruptedException {
   final HazelcastInstance hz = Hazelcast.newHazelcastInstance(createConfigWithDummyTxService());
   final String name = HazelcastTestSupport.generateRandomString(5);
   Thread producerThread = startProducerThread(hz, name);
   try {
     IQueue<String> q = hz.getQueue(name);
     for (int i = 0; i < 1000; i++) {
       String id = q.poll();
       if (id != null) {
         MultiMap<Object, Object> multiMap = hz.getMultiMap(name);
         assertEquals(1, multiMap.valueCount(id));
         multiMap.remove(id);
       } else {
         LockSupport.parkNanos(100);
       }
     }
   } finally {
     stopProducerThread(producerThread);
   }
 }
示例#24
0
  /**
   * Wait for signal with no spurious wakeup. Exclusive latch must be held, which is still held when
   * method returns.
   *
   * @param node newly allocated node
   * @param nanosTimeout relative nanosecond time to wait; infinite if <0
   * @param nanosEnd absolute nanosecond time to wait until; used only with >0 timeout
   * @return -1 if interrupted, 0 if timed out, 1 if signaled
   */
  int await(Latch latch, Node node, long nanosTimeout, long nanosEnd) {
    node.mWaiter = Thread.currentThread();

    Node tail = mTail;
    if (tail == null) {
      mHead = node;
    } else {
      tail.mNext = node;
      node.mPrev = tail;
    }
    mTail = node;

    if (nanosTimeout < 0) {
      while (true) {
        latch.releaseExclusive();
        LockSupport.park();
        latch.acquireExclusive();
        int state = node.resumed(this);
        if (state != 0) {
          return state;
        }
      }
    } else {
      while (true) {
        latch.releaseExclusive();
        LockSupport.parkNanos(nanosTimeout);
        latch.acquireExclusive();
        int state = node.resumed(this);
        if (state != 0) {
          return state;
        }
        if (nanosTimeout == 0 || (nanosTimeout = nanosEnd - System.nanoTime()) <= 0) {
          node.remove(this);
          return 0;
        }
      }
    }
  }
示例#25
0
 /**
  * Spins/blocks until node s is fulfilled.
  *
  * @param s the waiting node
  * @param e the comparison value for checking match
  * @param timed true if timed wait
  * @param nanos timeout value
  * @return matched item, or s if cancelled
  */
 Object awaitFulfill(QNode s, Object e, boolean timed, long nanos) {
   /* Same idea as TransferStack.awaitFulfill */
   long lastTime = timed ? System.nanoTime() : 0;
   Thread w = Thread.currentThread();
   int spins = ((head.next == s) ? (timed ? maxTimedSpins : maxUntimedSpins) : 0);
   for (; ; ) {
     if (w.isInterrupted()) s.tryCancel(e);
     Object x = s.item;
     if (x != e) return x;
     if (timed) {
       long now = System.nanoTime();
       nanos -= now - lastTime;
       lastTime = now;
       if (nanos <= 0) {
         s.tryCancel(e);
         continue;
       }
     }
     if (spins > 0) --spins;
     else if (s.waiter == null) s.waiter = w;
     else if (!timed) LockSupport.park(this);
     else if (nanos > spinForTimeoutThreshold) LockSupport.parkNanos(this, nanos);
   }
 }
示例#26
0
  @SuppressWarnings("NestedAssignment")
  public static void main(String[] args) throws Exception {
    Robot robot = new Robot();
    int steps = 3;

    while (true) {
      Point p = MouseInfo.getPointerInfo().getLocation();

      move(robot, p.x += steps, p.y);

      // update the pointer location, else you block the user's movement
      // (the pointer would move to the initial location instead of following the user's movement)
      p = MouseInfo.getPointerInfo().getLocation();
      move(robot, p.x, p.y += steps);

      p = MouseInfo.getPointerInfo().getLocation();
      move(robot, p.x -= steps, p.y);

      p = MouseInfo.getPointerInfo().getLocation();
      move(robot, p.x, p.y -= steps);

      LockSupport.parkNanos(TimeUnit.MINUTES.toNanos(2));
    }
  }
示例#27
0
 @Test
 public void park() {
   LockSupport.parkNanos(this, TimeUnit.SECONDS.toNanos(10));
 }
  // Might throw.
  private SQLiteConnection waitForConnection(
      String sql, int connectionFlags, CancellationSignal cancellationSignal) {
    final boolean wantPrimaryConnection =
        (connectionFlags & CONNECTION_FLAG_PRIMARY_CONNECTION_AFFINITY) != 0;

    final ConnectionWaiter waiter;
    final int nonce;
    synchronized (mLock) {
      throwIfClosedLocked();

      // Abort if canceled.
      if (cancellationSignal != null) {
        cancellationSignal.throwIfCanceled();
      }

      // Try to acquire a connection.
      SQLiteConnection connection = null;
      if (!wantPrimaryConnection) {
        connection = tryAcquireNonPrimaryConnectionLocked(sql, connectionFlags); // might throw
      }
      if (connection == null) {
        connection = tryAcquirePrimaryConnectionLocked(connectionFlags); // might throw
      }
      if (connection != null) {
        return connection;
      }

      // No connections available.  Enqueue a waiter in priority order.
      final int priority = getPriority(connectionFlags);
      final long startTime = SystemClock.uptimeMillis();
      waiter =
          obtainConnectionWaiterLocked(
              Thread.currentThread(),
              startTime,
              priority,
              wantPrimaryConnection,
              sql,
              connectionFlags);
      ConnectionWaiter predecessor = null;
      ConnectionWaiter successor = mConnectionWaiterQueue;
      while (successor != null) {
        if (priority > successor.mPriority) {
          waiter.mNext = successor;
          break;
        }
        predecessor = successor;
        successor = successor.mNext;
      }
      if (predecessor != null) {
        predecessor.mNext = waiter;
      } else {
        mConnectionWaiterQueue = waiter;
      }

      nonce = waiter.mNonce;
    }

    // Set up the cancellation listener.
    if (cancellationSignal != null) {
      cancellationSignal.setOnCancelListener(
          new CancellationSignal.OnCancelListener() {
            @Override
            public void onCancel() {
              synchronized (mLock) {
                if (waiter.mNonce == nonce) {
                  cancelConnectionWaiterLocked(waiter);
                }
              }
            }
          });
    }
    try {
      // Park the thread until a connection is assigned or the pool is closed.
      // Rethrow an exception from the wait, if we got one.
      long busyTimeoutMillis = CONNECTION_POOL_BUSY_MILLIS;
      long nextBusyTimeoutTime = waiter.mStartTime + busyTimeoutMillis;
      for (; ; ) {
        // Detect and recover from connection leaks.
        if (mConnectionLeaked.compareAndSet(true, false)) {
          synchronized (mLock) {
            wakeConnectionWaitersLocked();
          }
        }

        // Wait to be unparked (may already have happened), a timeout, or interruption.
        LockSupport.parkNanos(this, busyTimeoutMillis * 1000000L);

        // Clear the interrupted flag, just in case.
        Thread.interrupted();

        // Check whether we are done waiting yet.
        synchronized (mLock) {
          throwIfClosedLocked();

          final SQLiteConnection connection = waiter.mAssignedConnection;
          final RuntimeException ex = waiter.mException;
          if (connection != null || ex != null) {
            recycleConnectionWaiterLocked(waiter);
            if (connection != null) {
              return connection;
            }
            throw ex; // rethrow!
          }

          final long now = SystemClock.uptimeMillis();
          if (now < nextBusyTimeoutTime) {
            busyTimeoutMillis = now - nextBusyTimeoutTime;
          } else {
            logConnectionPoolBusyLocked(now - waiter.mStartTime, connectionFlags);
            busyTimeoutMillis = CONNECTION_POOL_BUSY_MILLIS;
            nextBusyTimeoutTime = now + busyTimeoutMillis;
          }
        }
      }
    } finally {
      // Remove the cancellation listener.
      if (cancellationSignal != null) {
        cancellationSignal.setOnCancelListener(null);
      }
    }
  }
 @Override
 public void run() throws Exception {
   LockSupport.parkNanos(delayNs);
 }
 @Override
 protected void backoff() {
   LockSupport.parkNanos(1L);
 }