/**
* Waits for the channel to become terminated, giving up if the timeout is reached.
*
* @return whether the channel is terminated, as would be done by {@link #isTerminated()}.
*/
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
synchronized (lock) {
long timeoutNanos = unit.toNanos(timeout);
long endTimeNanos = System.nanoTime() + timeoutNanos;
while (!terminated && (timeoutNanos = endTimeNanos - System.nanoTime()) > 0) {
TimeUnit.NANOSECONDS.timedWait(lock, timeoutNanos);
}
return terminated;
}
}
/**
* Causes the current thread to wait until this instance acquires leadership unless the thread is
* {@linkplain Thread#interrupt interrupted}, the specified waiting time elapses or the instance
* is {@linkplain #close() closed}.
*
* <p>If this instance already is the leader then this method returns immediately with the value
* {@code true}.
*
* <p>Otherwise the current thread becomes disabled for thread scheduling purposes and lies
* dormant until one of four things happen:
*
* <ul>
* <li>This instance becomes the leader
* <li>Some other thread {@linkplain Thread#interrupt interrupts} the current thread
* <li>The specified waiting time elapses.
* <li>The instance is {@linkplain #close() closed}
* </ul>
*
* <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 or the instance is {@linkplain #close() closed} 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 or the instances was closed
* @throws InterruptedException if the current thread is interrupted while waiting
*/
public boolean await(long timeout, TimeUnit unit) throws InterruptedException {
long waitNanos = TimeUnit.NANOSECONDS.convert(timeout, unit);
synchronized (this) {
while ((waitNanos > 0) && (state.get() == State.STARTED) && !hasLeadership.get()) {
long startNanos = System.nanoTime();
TimeUnit.NANOSECONDS.timedWait(this, waitNanos);
long elapsed = System.nanoTime() - startNanos;
waitNanos -= elapsed;
}
}
return hasLeadership();
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
long nanos = unit.toNanos(timeout);
synchronized (lock) {
while (true) {
if (shutdown && runningTasks == 0) {
return true;
} else if (nanos <= 0) {
return false;
} else {
long now = System.nanoTime();
TimeUnit.NANOSECONDS.timedWait(lock, nanos);
nanos -= System.nanoTime() - now; // subtract the actual time we waited
}
}
}
}
/** {@inheritDoc} */
@Override
public void await(Object obj) throws InterruptedException, TimeoutException {
long r = getRemains();
TimeUnit.NANOSECONDS.timedWait(obj, r);
}