/** * Returns the successfully completed value immediately. * * @throws {@link IllegalStateException} if not completed successfully. **/ public T get() { Preconditions.checkState(isCompletedSuccessfully()); return future.join(); }
/** * Tests the provided predicate against the value of this result, if it has completed successfully. If it has * not yet completed, or has failed or timed out, the predicate is not executed and {@code false} is returned. */ public boolean test(Predicate<T> predicateIfCompletedSuccessfully) { if (isCompletedSuccessfully()) { return predicateIfCompletedSuccessfully.test(get()); } return false; }
private void requestComplete( RequestInfo requestInfo, AsyncResult<?> result, long blockingTimeMillis) { events.requestComplete(blockingTimeMillis); if (blockingTimeMillis == 0 || blockingTimeMillis < thresholdMillis.get()) { return; } if (result.isCompletedSuccessfully()) { events.successfulSlowAcquisition(requestInfo, blockingTimeMillis); } else if (result.isTimedOut()) { events.timedOutSlowAcquisition(requestInfo, blockingTimeMillis); } }
private void assertNotLocked(ExclusiveLock lock) { assertThat(lock.lock(UUID.randomUUID()).isCompletedSuccessfully()).isTrue(); }
@Test public void multipleWaitUntilAvailableRequestsAllCompleteWhenLockIsFree() { lockSynchronously(REQUEST_1); AsyncResult<Void> request2 = waitUntilAvailableAsync(REQUEST_2); AsyncResult<Void> request3 = lock.waitUntilAvailable(REQUEST_3); unlock(REQUEST_1); assertThat(request2.isCompletedSuccessfully()).isTrue(); assertThat(request3.isCompletedSuccessfully()).isTrue(); }
@Test public void multipleQueuedRequestsCanObtainLock() { lockSynchronously(REQUEST_1); AsyncResult<Void> result2 = lockAsync(REQUEST_2); AsyncResult<Void> result3 = lockAsync(REQUEST_3); unlock(REQUEST_1); assertThat(result2.isCompletedSuccessfully()).isTrue(); assertThat(result3.isComplete()).isFalse(); unlock(REQUEST_2); assertThat(result3.isCompletedSuccessfully()).isTrue(); }
@Test public void waitForLocksRequestsAreIdempotent() { LockToken token = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> request = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); AsyncResult<Void> duplicate = service.waitForLocks(REQUEST_2, descriptors(LOCK_A), SHORT_TIMEOUT); assertThat(request).isEqualTo(duplicate); service.unlock(token); assertThat(request.isCompletedSuccessfully()).isTrue(); assertThat(duplicate.isCompletedSuccessfully()).isTrue(); }
@Test public void requestsAreIdempotentDuringAcquisitionPhase() { LockToken currentHolder = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> tokenResult = lock(REQUEST_2, LOCK_A); AsyncResult<LockToken> duplicateResult = lock(REQUEST_2, LOCK_A); service.unlock(currentHolder); assertThat(tokenResult.isCompletedSuccessfully()).isTrue(); assertThat(duplicateResult.isCompletedSuccessfully()).isTrue(); assertThat(tokenResult.get()).isEqualTo(duplicateResult.get()); }
@Test public void waitUntilAvailableWantsUntilLockIsFree() { lockSynchronously(REQUEST_1); AsyncResult<Void> result = waitUntilAvailableAsync(REQUEST_2); assertThat(result.isComplete()).isFalse(); unlock(REQUEST_1); assertThat(result.isCompletedSuccessfully()).isTrue(); }
@Test public void unlockByWaiterNoOps() { lockSynchronously(REQUEST_1); AsyncResult<Void> request2 = lockAsync(REQUEST_2); unlock(REQUEST_2); assertThat(lock.getCurrentHolder()).isEqualTo(REQUEST_1); assertThat(request2.isComplete()).isFalse(); // request2 should still get the lock when it's available unlock(REQUEST_1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void enqueueingSameRequestIdTwiceThrowsAndDoesNotAffectState() { lockSynchronously(REQUEST_1); AsyncResult<Void> request2 = lockAsync(REQUEST_2); assertThatThrownBy(() -> lockAsync(REQUEST_2)).isInstanceOf(IllegalStateException.class); // request 2 should still get the lock when available unlock(REQUEST_1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void waitingRequestGetsTheLockAfterItIsUnlocked() { LockToken request1 = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A); assertThat(request2.isComplete()).isFalse(); service.unlock(request1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void waitingRequestGetsTheLockAfterItIsUnlockedWithMultipleLocks() { LockToken request1 = lockSynchronously(REQUEST_1, LOCK_A, LOCK_C); AsyncResult<LockToken> request2 = lock(REQUEST_2, LOCK_A, LOCK_B, LOCK_C, LOCK_D); assertThat(request2.isComplete()).isFalse(); service.unlock(request1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void canWaitForLock() { LockToken lockAHolder = lockSynchronously(REQUEST_1, LOCK_A); AsyncResult<Void> waitResult = waitForLocks(REQUEST_2, LOCK_A); assertThat(waitResult.isComplete()).isFalse(); service.unlock(lockAHolder); assertThat(waitResult.isCompletedSuccessfully()).isTrue(); assertNotLocked(LOCK_A); }
@Test public void waitUntilAvailableDoesNotBlockLockRequests() { lockSynchronously(REQUEST_1); waitUntilAvailableAsync(REQUEST_2); AsyncResult<Void> lockRequest = lockAsync(REQUEST_3); assertThat(lockRequest.isComplete()).isFalse(); unlock(REQUEST_1); assertThat(lockRequest.isCompletedSuccessfully()).isTrue(); }
@Test public void queuedRequestObtainsLockAfterBeingUnlocked() { lockSynchronously(REQUEST_1); AsyncResult<Void> result = lockAsync(REQUEST_2); unlock(REQUEST_1); assertThat(result.isCompletedSuccessfully()).isTrue(); }
@Test public void timeoutDoesNothingIfLockIsAlreadyAcquired() { lockSynchronously(REQUEST_1); lock.timeout(REQUEST_1); // lock should still be locked, and able to be unlocked AsyncResult<Void> request2 = lockAsync(REQUEST_2); assertThat(request2.isComplete()).isFalse(); unlock(REQUEST_1); assertThat(request2.isCompletedSuccessfully()).isTrue(); }
@Test public void canWaitForMultipleLocks() { LockToken lockAHolder = lockSynchronously(REQUEST_1, LOCK_B, LOCK_C); AsyncResult<Void> waitResult = waitForLocks(REQUEST_2, LOCK_A, LOCK_B, LOCK_C); assertThat(waitResult.isComplete()).isFalse(); assertNotLocked(LOCK_A); service.unlock(lockAHolder); assertThat(waitResult.isCompletedSuccessfully()).isTrue(); assertNotLocked(LOCK_A); assertNotLocked(LOCK_C); }
@Test public void queuesAcquisitionsForHeldLocks() { lockA.lock(OTHER_REQUEST_ID); lockB.lock(OTHER_REQUEST_ID); AsyncResult<HeldLocks> acquisitions = acquire(lockA, lockB); lockA.unlock(OTHER_REQUEST_ID); assertFalse(acquisitions.isComplete()); lockB.unlock(OTHER_REQUEST_ID); assertThat(acquisitions.isCompletedSuccessfully()).isTrue(); }
/** * Returns the successfully completed value immediately. * * @throws {@link IllegalStateException} if not completed successfully. **/ public T get() { Preconditions.checkState(isCompletedSuccessfully()); return future.join(); }