): T? {
      return taskRunner.withLock {
        val waitUntil = nanoTime + unit.toNanos(timeout)
        while (true) {
          val result = poll()
          if (result != null) return@withLock result
          if (nanoTime >= waitUntil) return@withLock null
          val editCountBefore = editCount
          yieldUntil { nanoTime >= waitUntil || editCount > editCountBefore }
        }

 * (by default) uses {@link System#nanoTime}, it is unaffected by these changes.
 *
 * <p>Use this class instead of direct calls to {@link System#nanoTime} for two reasons:
 *
 * <ul>
 *   <li>The raw {@code long} values returned by {@code nanoTime} are meaningless and unsafe to use
 *       in any other way than how {@code Stopwatch} uses them.

 * (by default) uses {@link System#nanoTime}, it is unaffected by these changes.
 *
 * <p>Use this class instead of direct calls to {@link System#nanoTime} for two reasons:
 *
 * <ul>
 *   <li>The raw {@code long} values returned by {@code nanoTime} are meaningless and unsafe to use
 *       in any other way than how {@code Stopwatch} uses them.

        Int.MAX_VALUE,
        // keepAliveTime:
        60L,
        TimeUnit.SECONDS,
        SynchronousQueue(),
        threadFactory,
      )

    override fun nanoTime() = System.nanoTime()

    override fun coordinatorNotify(taskRunner: TaskRunner) {
      taskRunner.notify()
    }

    /**
     * Wait a duration in nanoseconds. Unlike [java.lang.Object.wait] this interprets 0 as

  internal fun scheduleAndDecide(
    task: Task,
    delayNanos: Long,
    recurrence: Boolean,
  ): Boolean {
    task.initQueue(this)

    val now = taskRunner.backend.nanoTime()
    val executeNanoTime = now + delayNanos

    // If the task is already scheduled, take the earlier of the two times.
    val existingIndex = futureTasks.indexOf(task)
    if (existingIndex != -1) {

      long end = System.nanoTime() + remainingNanos;

      while (true) {
        try {
          // CountDownLatch treats negative timeouts just like zero.
          return latch.await(remainingNanos, NANOSECONDS);
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }
    } finally {

    if (localValue != null & notInstanceOfDelegatingToFuture(localValue)) {
      return getDoneValue(localValue);
    }
    // we delay calling nanoTime until we know we will need to either park or spin
    long endNanos = remainingNanos > 0 ? System.nanoTime() + remainingNanos : 0;
    long_wait_loop:
    if (remainingNanos >= SPIN_THRESHOLD_NANOS) {
      Waiter oldHead = waitersField;

   * - System.nanoTime() is expensive enough that we want to call it the minimum required number of
   *   times, typically once before invoking a blocking method. This often requires keeping track of
   *   the first time in a method that nanoTime() has been invoked, for which the special value 0L
   *   is reserved to mean "uninitialized". If timeout is non-positive, then nanoTime need never be
   *   called.

		return errMalformedAuth
	}

	if err = validateStorageRequestToken(token); err != nil {
		return err
	}

	nanoTime, err := strconv.ParseInt(r.Header.Get("X-Minio-Time"), 10, 64)
	if err != nil {
		return errMalformedAuth
	}

	localTime := UTCNow()
	remoteTime := time.Unix(0, nanoTime)

	delta := remoteTime.Sub(localTime)
	if delta < 0 {
		delta *= -1
	}

	if delta > DefaultSkewTime {

    ioe: IOException,
  ) = onEvent(ResponseFailed(System.nanoTime(), call, ioe))

  override fun callEnd(call: Call) = onEvent(CallEnd(System.nanoTime(), call))

  override fun callFailed(
    call: Call,
    ioe: IOException,
  ) = onEvent(CallFailed(System.nanoTime(), call, ioe))

  override fun canceled(call: Call) = onEvent(Canceled(System.nanoTime(), call))

  override fun satisfactionFailure(
    call: Call,