/** * Awaits for condition ignoring interrupts. * * @param cond Condition to await for. */ public static void awaitQuiet(Condition cond) { cond.awaitUninterruptibly(); }
@Override public void awaitUninterruptibly() { delegate().awaitUninterruptibly(); }
@Override public void awaitUninterruptibly() { delegate().awaitUninterruptibly(); }
public void stopAndAwaitAllJobs() { lock.lock(); try { stopped = true; while ( !executingJobs.isEmpty() ) { allJobsFinished.awaitUninterruptibly(); } } finally { lock.unlock(); } } }
@Override public void awaitUninterruptibly() { delegate().awaitUninterruptibly(); }
@Override public void awaitUninterruptibly() { lock.lock(); try { condition.awaitUninterruptibly(); } finally { lock.unlock(); } }
public void waitUntilCanExecuteMoreSamplingJobs() { lock.lock(); try { while ( !canExecuteMoreSamplingJobs() ) { if ( stopped ) { return; } canSchedule.awaitUninterruptibly(); } } finally { lock.unlock(); } }
@Override public void awaitUninterruptibly() { delegate().awaitUninterruptibly(); }
private void waitForSafePoint() { consumeLock.lock(); try { int currentEpochAndState = epochAndState; if (writerBroken(currentEpochAndState) || this.writer == null) { return; } consumerScheduled.set(true); epochAndState = currentEpochAndState | 1; readyForRolling = false; consumeExecutor.execute(consumer); while (!readyForRolling) { readyForRollingCond.awaitUninterruptibly(); } } finally { consumeLock.unlock(); } }
void waitTillFired() { while (!isFired()) { lock.lock(); try { if (!isFired()) { condition.awaitUninterruptibly(); } } finally { lock.unlock(); } } }
/** * Remove a socket. Its handler will be called. * * @param sock The socket to remove. */ public void remove(DomainSocket sock) { lock.lock(); try { if (closed) return; toRemove.put(sock.fd, sock); kick(); while (true) { processedCond.awaitUninterruptibly(); if (!toRemove.containsKey(sock.fd)) { break; } } } finally { lock.unlock(); } }
@GuardedBy("lock") private void awaitUninterruptibly(Guard guard, boolean signalBeforeWaiting) { if (signalBeforeWaiting) { signalNextWaiter(); } beginWaitingFor(guard); try { do { guard.condition.awaitUninterruptibly(); } while (!guard.isSatisfied()); } finally { endWaitingFor(guard); } }
@GuardedBy("lock") private void awaitUninterruptibly(Guard guard, boolean signalBeforeWaiting) { if (signalBeforeWaiting) { signalNextWaiter(); } beginWaitingFor(guard); try { do { guard.condition.awaitUninterruptibly(); } while (!guard.isSatisfied()); } finally { endWaitingFor(guard); } }
kick(); while (true) { processedCond.awaitUninterruptibly(); if (!toAdd.contains(entry)) { break;
@GuardedBy("lock") private void awaitUninterruptibly(Guard guard, boolean signalBeforeWaiting) { if (signalBeforeWaiting) { signalNextWaiter(); } beginWaitingFor(guard); try { do { guard.condition.awaitUninterruptibly(); } while (!guard.isSatisfied()); } finally { endWaitingFor(guard); } }
condition.awaitUninterruptibly();
protected boolean waitUntilNotEmpty() throws IOException { while ((count == 0) && !finished) { notEmpty.awaitUninterruptibly(); if (_closed) { throw new IOException("Stream closed"); } } if ((count == 0) && finished) { return true; } return false; }
protected void waitUntilNotFull() throws IOException { while (count == buffer.length) { notFull.awaitUninterruptibly(); if (_closed) { throw new IOException("Stream closed"); } } }
/** * Awaits for condition ignoring interrupts. * * @param cond Condition to await for. */ public static void awaitQuiet(Condition cond) { cond.awaitUninterruptibly(); }
public void waitForSomeBlocked(int minBlocked) { lock.lock(); try { while(countBlocked < minBlocked) { countBlockedIncreased.awaitUninterruptibly(); } } finally { lock.unlock(); } }