public void waitForOthers() { lock.lock(); NumCount++; if (NumCount == NumWait) { workers.signalAll(); NumCount = 0; } else { try { workers.await(); } catch (InterruptedException e) { } } lock.unlock(); }
public void setDone(boolean b) { try { lock.lock(); done = b; if (!done) cv.signal(); } finally { lock.unlock(); } }
public void run() { try { lock.lock(); while (true) { try { if (done) { cv.await(); } else { nextCharacter(); cv.await(getPauseTime(), TimeUnit.MILLISECONDS); } } catch (InterruptedException ie) { return; } } } finally { lock.unlock(); } }
private void awaitAvailableConnection(long timeout, TimeUnit unit) throws InterruptedException { waitLock.lock(); waiter++; try { hasAvailableConnection.await(timeout, unit); } finally { waiter--; waitLock.unlock(); } }
public void deposit(int amount) { lock.lock(); // Acquire the lock try { balance += amount; System.out.println("Deposit " + amount + "\t\t\t\t\t" + getBalance()); newDeposit.signalAll(); } finally { lock.unlock(); // Release the lock } }
/** Notify the worker that new entry to delete appeared. */ void signal() { lock.lock(); try { force = true; cond.signalAll(); } finally { lock.unlock(); } }
private void signalAllAvailableConnection() { // Quick check if it's worth signaling to avoid locking if (waiter == 0) return; waitLock.lock(); try { hasAvailableConnection.signalAll(); } finally { waitLock.unlock(); } }
public void withdraw(int amount) { lock.lock(); // Acquire the lock try { while (balance < amount) { System.out.println("\t\t\tWait for a deposit"); newDeposit.await(); } balance -= amount; System.out.println("\t\t\tWithdraw " + amount + "\t\t" + getBalance()); } catch (InterruptedException ex) { ex.printStackTrace(); } finally { lock.unlock(); // Release the lock } }
/** {@inheritDoc} */ @Override protected void body() throws InterruptedException { if (log.isDebugEnabled()) log.debug("Delete worker started."); while (!cancelled) { lock.lock(); try { if (!cancelled && !force) cond.await(FREQUENCY, TimeUnit.MILLISECONDS); force = false; // Reset force flag. } finally { lock.unlock(); } if (!cancelled) delete(); } }
public void detectedCountedLoops() { for (LoopEx loop : loops()) { InductionVariables ivs = new InductionVariables(loop); LoopBeginNode loopBegin = loop.loopBegin(); FixedNode next = loopBegin.next(); while (next instanceof FixedGuardNode || next instanceof ValueAnchorNode) { next = ((FixedWithNextNode) next).next(); } if (next instanceof IfNode) { IfNode ifNode = (IfNode) next; boolean negated = false; if (!loopBegin.isLoopExit(ifNode.falseSuccessor())) { if (!loopBegin.isLoopExit(ifNode.trueSuccessor())) { continue; } negated = true; } LogicNode ifTest = ifNode.condition(); if (!(ifTest instanceof IntegerLessThanNode)) { if (ifTest instanceof IntegerBelowThanNode) { Debug.log("Ignored potential Counted loop at %s with |<|", loopBegin); } continue; } IntegerLessThanNode lessThan = (IntegerLessThanNode) ifTest; Condition condition = null; InductionVariable iv = null; ValueNode limit = null; if (loop.isOutsideLoop(lessThan.x())) { iv = ivs.get(lessThan.y()); if (iv != null) { condition = lessThan.condition().mirror(); limit = lessThan.x(); } } else if (loop.isOutsideLoop(lessThan.y())) { iv = ivs.get(lessThan.x()); if (iv != null) { condition = lessThan.condition(); limit = lessThan.y(); } } if (condition == null) { continue; } if (negated) { condition = condition.negate(); } boolean oneOff = false; switch (condition) { case LE: oneOff = true; // fall through case LT: if (iv.direction() != Direction.Up) { continue; } break; case GE: oneOff = true; // fall through case GT: if (iv.direction() != Direction.Down) { continue; } break; default: throw GraalInternalError.shouldNotReachHere(); } loop.setCounted( new CountedLoopInfo( loop, iv, limit, oneOff, negated ? ifNode.falseSuccessor() : ifNode.trueSuccessor())); } } }
/** * Asynchronous sequence update operation. Will add given amount to the sequence value. * * @param l Increment amount. * @param updateCall Cache call that will update sequence reservation count in accordance with l. * @param updated If {@code true}, will return sequence value after update, otherwise will return * sequence value prior to update. * @return Future indicating sequence value. * @throws GridException If update failed. */ private GridFuture<Long> internalUpdateAsync( long l, @Nullable Callable<Long> updateCall, boolean updated) throws GridException { checkRemoved(); A.ensure(l > 0, " Parameter mustn't be less then 1: " + l); lock.lock(); try { // If reserved range isn't exhausted. if (locVal + l <= upBound) { long curVal = locVal; locVal += l; return new GridFinishedFuture<Long>(ctx.kernalContext(), updated ? locVal : curVal); } } finally { lock.unlock(); } if (updateCall == null) updateCall = internalUpdate(l, updated); while (true) { if (updateGuard.compareAndSet(false, true)) { try { // This call must be outside lock. return ctx.closures().callLocalSafe(updateCall, true); } finally { lock.lock(); try { updateGuard.set(false); cond.signalAll(); } finally { lock.unlock(); } } } else { lock.lock(); try { while (locVal >= upBound && updateGuard.get()) { try { cond.await(500, MILLISECONDS); } catch (InterruptedException e) { throw new GridInterruptedException(e); } } checkRemoved(); // If reserved range isn't exhausted. if (locVal + l <= upBound) { long curVal = locVal; locVal += l; return new GridFinishedFuture<Long>(ctx.kernalContext(), updated ? locVal : curVal); } } finally { lock.unlock(); } } } }
/** * Synchronous sequence update operation. Will add given amount to the sequence value. * * @param l Increment amount. * @param updateCall Cache call that will update sequence reservation count in accordance with l. * @param updated If {@code true}, will return sequence value after update, otherwise will return * sequence value prior to update. * @return Sequence value. * @throws GridException If update failed. */ private long internalUpdate(long l, @Nullable Callable<Long> updateCall, boolean updated) throws GridException { checkRemoved(); assert l > 0; lock.lock(); try { // If reserved range isn't exhausted. if (locVal + l <= upBound) { long curVal = locVal; locVal += l; return updated ? locVal : curVal; } } finally { lock.unlock(); } if (updateCall == null) updateCall = internalUpdate(l, updated); while (true) { if (updateGuard.compareAndSet(false, true)) { try { // This call must be outside lock. return CU.outTx(updateCall, ctx); } finally { lock.lock(); try { updateGuard.set(false); cond.signalAll(); } finally { lock.unlock(); } } } else { lock.lock(); try { while (locVal >= upBound && updateGuard.get()) { try { cond.await(500, MILLISECONDS); } catch (InterruptedException e) { throw new GridInterruptedException(e); } } checkRemoved(); // If reserved range isn't exhausted. if (locVal + l <= upBound) { long curVal = locVal; locVal += l; return updated ? locVal : curVal; } } finally { lock.unlock(); } } } }