long nanos = expirationNanos;
      long now = System.nanoTime();
      if (nanos == 0 || now - nanos >= 0) {
        synchronized (lock) {
          if (nanos == expirationNanos) { // recheck for lost race
            T t = delegate.get();
            value = t;
            nanos = now + durationNanos;
            // In the very unlikely event that nanos is 0, set it to 1;

      long nanos = expirationNanos;
      long now = System.nanoTime();
      if (nanos == 0 || now - nanos >= 0) {
        synchronized (lock) {
          if (nanos == expirationNanos) { // recheck for lost race
            T t = delegate.get();
            value = t;
            nanos = now + durationNanos;
            // In the very unlikely event that nanos is 0, set it to 1;

    @Throws(InterruptedException::class)
    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
    override fun coordinatorWait(
      taskRunner: TaskRunner,
      nanos: Long,
    ) {
      taskRunner.assertLockHeld()
      if (nanos > 0) {
        taskRunner.awaitNanos(nanos)
      }
    }

    override fun <T> decorate(queue: BlockingQueue<T>) = queue

    override fun execute(
      taskRunner: TaskRunner,

        override fun coordinatorWait(
          taskRunner: TaskRunner,
          nanos: Long,
        ) {
          taskRunner.assertLockHeld()
          check(waitingCoordinatorTask == null)
          if (nanos == 0L) return

          // Yield until notified, interrupted, or the duration elapses.
          val waitUntil = nanoTime + nanos
          val self = currentTask
          waitingCoordinatorTask = self

       * if the timer expires, otherwise behaves like {@link #get()}.
       */
      V get(long nanos)
          throws TimeoutException, CancellationException, ExecutionException, InterruptedException {

        // Attempt to acquire the shared lock with a timeout.
        if (!tryAcquireSharedNanos(-1, nanos)) {
          throw new TimeoutException("Timeout waiting for task.");
        }

        return getValue();

  /** Caller should check before calling that guard is not satisfied. */
  @GuardedBy("lock")
  private boolean awaitNanos(Guard guard, long nanos, boolean signalBeforeWaiting)
      throws InterruptedException {
    boolean firstTime = true;
    try {
      do {
        if (nanos <= 0L) {
          return false;
        }
        if (firstTime) {
          if (signalBeforeWaiting) {

    long nanosPerSecond = NANOSECONDS.convert(1, SECONDS);
    assertThat(nanosPerSecond * Long.MAX_VALUE).isLessThan(0L);

    // Check that we wait long enough anyway (presumably as long as MAX_VALUE nanos):
    TimedWaiterThread waiter = new TimedWaiterThread(future, Long.MAX_VALUE, SECONDS);
    waiter.start();
    waiter.awaitWaiting();

    future.set(1);
    waiter.join();
  }

labels.facet_timestamp_1month=Último mes
labels.facet_timestamp_1year=Último año
labels.facet_timestamp_3month=Últimos 3 meses
labels.facet_timestamp_6month=Últimos 6 meses
labels.facet_timestamp_2year=Últimos 2 años
labels.facet_timestamp_3year=Últimos 3 años
labels.facet_contentLength_title=Tamaño
labels.facet_contentLength_10k=  - 10KB
labels.facet_contentLength_10kto100k=10KB - 100KB
labels.facet_contentLength_100kto500k=100KB - 500KB

labels.facet_timestamp_1month=Último mês
labels.facet_timestamp_1year=Último ano
labels.facet_timestamp_3month=Últimos 3 meses
labels.facet_timestamp_6month=Últimos 6 meses
labels.facet_timestamp_2year=Últimos 2 anos
labels.facet_timestamp_3year=Últimos 3 anos
labels.facet_contentLength_title=Tamanho
labels.facet_contentLength_10k=  - 10KB
labels.facet_contentLength_10kto100k=10KB - 100KB
labels.facet_contentLength_100kto500k=100KB - 500KB