Exemplo n.º 1
0
    public TimeUnit deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
        throws JsonParseException {
      String unit = json.getAsString();
      TimeUnit tu;

      try {
        tu = TimeUnit.from(unit);
      } catch (IllegalArgumentException e) {
        throw new ContextualJsonSyntaxException(
            unit, "is not a valid time unit, must be one of " + TimeUnit.toValueNames());
      }

      return tu;
    }
Exemplo n.º 2
0
 /**
  * Retrieves and removes the head of this queue, waiting if necessary until an element with an
  * expired delay is available on this queue, or the specified wait time expires.
  *
  * @return the head of this queue, or <tt>null</tt> if the specified waiting time elapses before
  *     an element with an expired delay becomes available
  * @throws InterruptedException {@inheritDoc}
  */
 public E poll(long timeout, TimeUnit unit) throws InterruptedException {
   long nanos = unit.toNanos(timeout);
   final ReentrantLock lock = this.lock;
   lock.lockInterruptibly();
   try {
     for (; ; ) {
       E first = q.peek();
       if (first == null) {
         if (nanos <= 0) return null;
         else nanos = available.awaitNanos(nanos);
       } else {
         long delay = first.getDelay(TimeUnit.NANOSECONDS);
         if (delay <= 0) return q.poll();
         if (nanos <= 0) return null;
         if (nanos < delay || leader != null) nanos = available.awaitNanos(nanos);
         else {
           Thread thisThread = Thread.currentThread();
           leader = thisThread;
           try {
             long timeLeft = available.awaitNanos(delay);
             nanos -= delay - timeLeft;
           } finally {
             if (leader == thisThread) leader = null;
           }
         }
       }
     }
   } finally {
     if (leader == null && q.peek() != null) available.signal();
     lock.unlock();
   }
 }
Exemplo n.º 3
0
 /**
  * Retrieves and removes the head of this queue, waiting if necessary until an element with an
  * expired delay is available on this queue, or the specified wait time expires.
  *
  * @return the head of this queue, or <tt>null</tt> if the specified waiting time elapses before
  *     an element with an expired delay becomes available
  * @throws InterruptedException {@inheritDoc}
  */
 public E poll(long timeout, TimeUnit unit) throws InterruptedException {
   long nanos = unit.toNanos(timeout);
   final ReentrantLock lock = this.lock;
   lock.lockInterruptibly();
   try {
     for (; ; ) {
       E first = q.peek();
       if (first == null) {
         if (nanos <= 0) return null;
         else nanos = available.awaitNanos(nanos);
       } else {
         long delay = first.getDelay(TimeUnit.NANOSECONDS);
         if (delay > 0) {
           if (nanos <= 0) return null;
           if (delay > nanos) delay = nanos;
           long timeLeft = available.awaitNanos(delay);
           nanos -= delay - timeLeft;
         } else {
           E x = q.poll();
           assert x != null;
           if (q.size() != 0) available.signalAll();
           return x;
         }
       }
     }
   } finally {
     lock.unlock();
   }
 }
Exemplo n.º 4
0
  /**
   * Wait until futures are complete or the supplied timeout is reached.
   *
   * @param timeout Maximum time to wait for futures to complete.
   * @param unit Unit of time for the timeout.
   * @param futures Futures to wait for.
   * @return True if all futures complete in time.
   */
  public boolean awaitAll(long timeout, TimeUnit unit, Future<?>... futures) {
    boolean complete;

    try {
      // 将timeout 转换为微秒
      long nanos = unit.toNanos(timeout);
      // 获取系统当前时间的微秒
      long time = System.nanoTime();

      for (Future<?> f : futures) {
        if (nanos < 0) return false;
        // 此处f的示例为Command
        f.get(nanos, TimeUnit.NANOSECONDS);
        long now = System.nanoTime();
        nanos -= now - time;
        time = now;
      }

      complete = true;
    } catch (TimeoutException e) {
      complete = false;
    } catch (Exception e) {
      throw new RedisCommandInterruptedException(e);
    }

    return complete;
  }
Exemplo n.º 5
0
  /** {@inheritDoc} */
  @Override
  public R get(long timeout, TimeUnit unit) throws GridException {
    A.ensure(timeout >= 0, "timeout cannot be negative: " + timeout);
    A.notNull(unit, "unit");

    checkValid();

    try {
      long now = System.currentTimeMillis();

      long end = timeout == 0 ? Long.MAX_VALUE : now + MILLISECONDS.convert(timeout, unit);

      // Account for overflow.
      if (end < 0) end = Long.MAX_VALUE;

      synchronized (mux) {
        while (!done && !cancelled && now < end) {
          mux.wait(end - now);

          if (!done) now = System.currentTimeMillis();
        }

        if (done) {
          if (err != null) throw U.cast(err);

          return res;
        }

        if (cancelled) throw new GridFutureCancelledException("Future was cancelled: " + this);

        throw new GridFutureTimeoutException(
            "Timeout was reached before computation completed [duration="
                + duration()
                + "ms, timeout="
                + unit.toMillis(timeout)
                + "ms]");
      }
    } catch (InterruptedException e) {
      throw new GridInterruptedException(
          "Got interrupted while waiting for future to complete [duration="
              + duration()
              + "ms, timeout="
              + unit.toMillis(timeout)
              + "ms]",
          e);
    }
  }
  /** {@inheritDoc} */
  @Override
  public R get(long timeout, TimeUnit unit) throws IgniteCheckedException {
    A.ensure(timeout >= 0, "timeout cannot be negative: " + timeout);
    A.notNull(unit, "unit");

    try {
      return get0(unit.toNanos(timeout));
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();

      throw new IgniteInterruptedCheckedException(
          "Got interrupted while waiting for future to complete.", e);
    }
  }
 public E poll(long timeout, TimeUnit unit) throws InterruptedException {
   long nanos = unit.toNanos(timeout);
   final ReentrantLock lock = this.lock;
   lock.lockInterruptibly();
   try {
     for (; ; ) {
       if (count != 0) {
         E x = extract();
         return x;
       }
       if (nanos <= 0) return null;
       try {
         nanos = notEmpty.awaitNanos(nanos);
       } catch (InterruptedException ie) {
         notEmpty.signal(); // propagate to non-interrupted thread
         throw ie;
       }
     }
   } finally {
     lock.unlock();
   }
 }
  /**
   * Inserts the specified element at the tail of this queue, waiting up to the specified wait time
   * for space to become available if the queue is full.
   *
   * @throws InterruptedException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   */
  public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {

    if (e == null) throw new NullPointerException();
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
      for (; ; ) {
        if (count != items.length) {
          insert(e);
          return true;
        }
        if (nanos <= 0) return false;
        try {
          nanos = notFull.awaitNanos(nanos);
        } catch (InterruptedException ie) {
          notFull.signal(); // propagate to non-interrupted thread
          throw ie;
        }
      }
    } finally {
      lock.unlock();
    }
  }
Exemplo n.º 9
0
 /**
  * Retrieves and removes the head of this queue, waiting if necessary up to the specified wait
  * time, for another thread to insert it.
  *
  * @return the head of this queue, or <tt>null</tt> if the specified waiting time elapses before
  *     an element is present.
  * @throws InterruptedException {@inheritDoc}
  */
 public E poll(long timeout, TimeUnit unit) throws InterruptedException {
   Object e = transferer.transfer(null, true, unit.toNanos(timeout));
   if (e != null || !Thread.interrupted()) return (E) e;
   throw new InterruptedException();
 }
Exemplo n.º 10
0
 /**
  * Inserts the specified element into this queue, waiting if necessary up to the specified wait
  * time for another thread to receive it.
  *
  * @return <tt>true</tt> if successful, or <tt>false</tt> if the specified waiting time elapses
  *     before a consumer appears.
  * @throws InterruptedException {@inheritDoc}
  * @throws NullPointerException {@inheritDoc}
  */
 public boolean offer(E o, long timeout, TimeUnit unit) throws InterruptedException {
   if (o == null) throw new NullPointerException();
   if (transferer.transfer(o, true, unit.toNanos(timeout)) != null) return true;
   if (!Thread.interrupted()) return false;
   throw new InterruptedException();
 }
Exemplo n.º 11
0
 /**
  * Sets the read timeout for the underlying {@link HttpURLConnection}
  * 
  * @param duration duration of the timeout
  * 
  * @param unit unit of time (milliseconds, seconds, etc)
  */
 public void setReadTimeout(int duration, TimeUnit unit)
 {
   this.readTimeout = unit.toMillis(duration);
 }
Exemplo n.º 12
0
 /**
  * Sets the connect timeout for the underlying {@link HttpURLConnection}
  * 
  * @param duration duration of the timeout
  * 
  * @param unit unit of time (milliseconds, seconds, etc)
  */
 public void setConnectTimeout(int duration, TimeUnit unit)
 {
   this.connectTimeout = unit.toMillis(duration);
 }
Exemplo n.º 13
0
 /** {@inheritDoc} */
 @Override
 public long getDelay(TimeUnit unit) {
   return unit.convert(nextFlushTime() - U.currentTimeMillis(), TimeUnit.MILLISECONDS);
 }
Exemplo n.º 14
0
 public long getDelay(TimeUnit unit) {
   return unit.convert(trigger - System.nanoTime(), NANOSECONDS);
 }
 /**
  * Acquires the lock if it is not held by another thread within the given waiting time and the
  * current thread has not been {@link Thread#interrupt interrupted}.
  *
  * <p>Acquires the lock if it is not held by another thread and returns immediately with the value
  * <tt>true</tt>, setting the lock hold count to one. If this lock has been set to use a fair
  * ordering policy then an available lock <em>will not</em> be acquired if any other threads are
  * waiting for the lock. This is in contrast to the {@link #tryLock()} method. If you want a timed
  * <tt>tryLock</tt> that does permit barging on a fair lock then combine the timed and un-timed
  * forms together:
  *
  * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
  * </pre>
  *
  * <p>If the current thread already holds this lock then the hold count is incremented by one and
  * the method returns <tt>true</tt>.
  *
  * <p>If the lock is held by another thread then the current thread becomes disabled for thread
  * scheduling purposes and lies dormant until one of three things happens:
  *
  * <ul>
  *   <li>The lock is acquired by the current thread; or
  *   <li>Some other thread {@link Thread#interrupt interrupts} the current thread; or
  *   <li>The specified waiting time elapses
  * </ul>
  *
  * <p>If the lock is acquired then the value <tt>true</tt> is returned and the lock hold count is
  * set to one.
  *
  * <p>If the current thread:
  *
  * <ul>
  *   <li>has its interrupted status set on entry to this method; or
  *   <li>is {@link Thread#interrupt interrupted} while acquiring the lock,
  * </ul>
  *
  * then {@link InterruptedException} is thrown and the current thread's interrupted status is
  * cleared.
  *
  * <p>If the specified waiting time elapses then the value <tt>false</tt> is returned. If the time
  * is less than or equal to zero, the method will not wait at all.
  *
  * <p>In this implementation, as this method is an explicit interruption point, preference is
  * given to responding to the interrupt over normal or reentrant acquisition of the lock, and over
  * reporting the elapse of the waiting time.
  *
  * @param timeout the time to wait for the lock
  * @param unit the time unit of the timeout argument
  * @return <tt>true</tt> if the lock was free and was acquired by the current thread, or the lock
  *     was already held by the current thread; and <tt>false</tt> if the waiting time elapsed
  *     before the lock could be acquired.
  * @throws InterruptedException if the current thread is interrupted
  * @throws NullPointerException if unit is null
  */
 public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
   return sync.tryLock(unit.toNanos(timeout));
 }