/** {@inheritDoc} */
 @Override
 public long getDelay(TimeUnit unit) {
   return unit.convert(nextFlushTime() - U.currentTimeMillis(), TimeUnit.MILLISECONDS);
 }
Example #2
0
 /**
  * Causes the current thread to wait until the latch has counted down to zero, unless the thread
  * is {@linkplain Thread#interrupt interrupted}, or the specified waiting time elapses.
  *
  * <p>If the current count is zero then this method returns immediately with the value {@code
  * true}.
  *
  * <p>If the current count is greater than zero then the current thread becomes disabled for
  * thread scheduling purposes and lies dormant until one of three things happen:
  *
  * <ul>
  *   <li>The count reaches zero due to invocations of the {@link #countDown} method; or
  *   <li>Some other thread {@linkplain Thread#interrupt interrupts} the current thread; or
  *   <li>The specified waiting time elapses.
  * </ul>
  *
  * <p>If the count reaches zero then the method returns with the value {@code true}.
  *
  * <p>If the current thread:
  *
  * <ul>
  *   <li>has its interrupted status set on entry to this method; or
  *   <li>is {@linkplain Thread#interrupt interrupted} while waiting,
  * </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 {@code false} is returned. If the time
  * is less than or equal to zero, the method will not wait at all.
  *
  * @param timeout the maximum time to wait
  * @param unit the time unit of the {@code timeout} argument
  * @return {@code true} if the count reached zero and {@code false} if the waiting time elapsed
  *     before the count reached zero
  * @throws InterruptedException if the current thread is interrupted while waiting
  */
 public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
   return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
 }