/** {@inheritDoc} */
@Override
public long getDelay(TimeUnit unit) {
return unit.convert(nextFlushTime() - U.currentTimeMillis(), TimeUnit.MILLISECONDS);
}
/**
* 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));
}
