private boolean _suspend(long time, TimeUnit unit, boolean failOnError) throws IllegalStateException { boolean suspendSuccessful = false; try { executionStateMonitor.enter(); switch (executionState) { case RESUMED: break; case SUSPENDED: case CANCELLED: if (failOnError) { throw new IllegalStateException( LocalizationMessages.ILLEGAL_INVOCATION_CONTEXT_STATE(executionState, "suspend")); } break; case RUNNING: executionState = State.SUSPENDED; suspendSuccessful = true; } } finally { executionStateMonitor.leave(); } // we don't want to invoke the callback or log message // as part of the synchronized code if (suspendSuccessful) { callback.suspended(time, unit, this); } else { // already resumed - just log fine message & ignore the call LOGGER.log(Level.FINE, LocalizationMessages.REQUEST_SUSPEND_FAILED(executionState)); } return suspendSuccessful; }
public void unlock(Object name) { Monitor lock; synchronized (stringLocks) { lock = stringLocks.getUnchecked(name); } lock.leave(); }
/** * Invoke request on the wrapped inflector. The adapter itself serves as a {@link ListenableFuture * listenable response future}. * * @param request request data to be processed. */ public ListenableFuture<RESPONSE> apply(REQUEST request) { originatingRequest.set(request); final RESPONSE response; try { response = wrapped.apply(request); if (executionStateMonitor.enterIf(runningState)) { // The context was not suspended during the call to the wrapped inflector's apply(...) // method; // mark as resumed & don't invoke callback.resume() since we are resuming synchronously try { executionState = State.RESUMED; set(response); } finally { executionStateMonitor.leave(); } } else if (response != null) { LOGGER.log(Level.FINE, LocalizationMessages.REQUEST_SUSPENDED_RESPONSE_IGNORED(response)); } } catch (Throwable t) { resume(t); // resume with throwable (if not resumed by an external event already) } return this; }
public CountingReference<V> acquire(V val) { monitor.enter(); try { return intern(val).increment(); } finally { monitor.leave(); } }
public boolean isShutdown() { monitor.enter(); try { return isShutdown; } finally { monitor.leave(); } }
public boolean awaitTermination(long time, TimeUnit unit) throws InterruptedException { monitor.enter(); try { return monitor.waitFor(isTerminated, time, unit); } finally { monitor.leave(); } }
public void shutdown() { monitor.enter(); try { isShutdown = true; } finally { monitor.leave(); } }
public void decrement() { monitor.enter(); try { count--; } finally { monitor.leave(); } }
public void release(V val) { monitor.enter(); try { intern(val).decrement(); } finally { monitor.leave(); } }
private void enterSatisfyGuardAndLeaveInCurrentThread() { monitor.enter(); try { guard.setSatisfied(true); } finally { monitor.leave(); } }
@Override public State state() { executionStateMonitor.enter(); try { return executionState; } finally { executionStateMonitor.leave(); } }
@Override public boolean isSuspended() { try { executionStateMonitor.enter(); return executionState == State.SUSPENDED; } finally { executionStateMonitor.leave(); } }
public boolean increment() { monitor.enter(); try { if (isShutdown) { return false; } else { count++; return true; } } finally { monitor.leave(); } }
@Override public void cancel() { if (executionStateMonitor.enterIf(cancellableState)) { try { executionState = State.CANCELLED; } finally { executionStateMonitor.leave(); } super.cancel(true); } else { // just log fine message & ignore the call LOGGER.log(Level.FINE, LocalizationMessages.REQUEST_CANCEL_FAILED(executionState)); } }
private void resume(final Runnable resumeHandler) { if (executionStateMonitor.enterIf(resumableState)) { final boolean invokeCallback; try { invokeCallback = executionState == State.SUSPENDED; executionState = State.RESUMED; } finally { executionStateMonitor.leave(); } try { resumeHandler.run(); } finally { if (invokeCallback) { callback.resumed(); } } } else { throw new IllegalStateException( LocalizationMessages.ILLEGAL_INVOCATION_CONTEXT_STATE(executionState, "resume")); } }
private void runEnterTest() { assertFalse(Thread.currentThread().isInterrupted()); assertFalse(monitor.isOccupiedByCurrentThread()); doEnterScenarioSetUp(); boolean interruptedBeforeCall = Thread.currentThread().isInterrupted(); Outcome actualOutcome = doCall(); boolean occupiedAfterCall = monitor.isOccupiedByCurrentThread(); boolean interruptedAfterCall = Thread.currentThread().isInterrupted(); if (occupiedAfterCall) { guard.setSatisfied(true); monitor.leave(); assertFalse(monitor.isOccupiedByCurrentThread()); } assertEquals(expectedOutcome, actualOutcome); assertEquals(expectedOutcome == Outcome.SUCCESS, occupiedAfterCall); assertEquals( interruptedBeforeCall && expectedOutcome != Outcome.INTERRUPT, interruptedAfterCall); }
private void runWaitTest() { assertFalse(Thread.currentThread().isInterrupted()); assertFalse(monitor.isOccupiedByCurrentThread()); monitor.enter(); try { assertTrue(monitor.isOccupiedByCurrentThread()); doWaitScenarioSetUp(); boolean interruptedBeforeCall = Thread.currentThread().isInterrupted(); Outcome actualOutcome = doCall(); boolean occupiedAfterCall = monitor.isOccupiedByCurrentThread(); boolean interruptedAfterCall = Thread.currentThread().isInterrupted(); assertEquals(expectedOutcome, actualOutcome); assertTrue(occupiedAfterCall); assertEquals( interruptedBeforeCall && expectedOutcome != Outcome.INTERRUPT, interruptedAfterCall); } finally { guard.setSatisfied(true); monitor.leave(); assertFalse(monitor.isOccupiedByCurrentThread()); } }
@Override protected void tearDown() throws Exception { // We don't want to leave stray threads running after each test. At this point, every thread // launched by this test is either: // // (a) Blocked attempting to enter the monitor. // (b) Waiting for the single guard to become satisfied. // (c) Occupying the monitor and awaiting the tearDownLatch. // // Except for (c), every thread should occupy the monitor very briefly, and every thread leaves // the monitor with the guard satisfied. Therefore as soon as tearDownLatch is triggered, we // should be able to enter the monitor, and then we set the guard to satisfied for the benefit // of any remaining waiting threads. tearDownLatch.countDown(); assertTrue( "Monitor still occupied in tearDown()", monitor.enter(UNEXPECTED_HANG_DELAY_MILLIS, TimeUnit.MILLISECONDS)); try { guard.setSatisfied(true); } finally { monitor.leave(); } }