Java CompletableFuture.join方法代码示例

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
private void testValueFactoryReentersValueFactoryAsynchronously(boolean specifyJff) {
	// use our own so we don't get main thread deadlocks, which isn't the point of this test.
	JoinableFutureFactory jtf = specifyJff ? new JoinableFutureContext().getFactory() : null;
	StrongBox<AsyncLazy<Object>> lazy = new StrongBox<>();
	AtomicBoolean executed = new AtomicBoolean(false);
	lazy.value = new AsyncLazy<>(() -> {
		Assert.assertFalse(executed.get());
		executed.set(true);
		return Async.awaitAsync(
			Async.yieldAsync(),
			() -> Async.awaitAsync(
				lazy.value.getValueAsync(),
				() -> CompletableFuture.completedFuture(new Object())));
	}, jtf);

	CompletableFuture<Void> asyncTest = Async.awaitAsync(
		AsyncAssert.assertThrowsAsync(IllegalStateException.class, () -> lazy.value.getValueAsync()),
		() -> {
			// Do it again, to verify that AsyncLazy recorded the failure and will replay it.
			return Async.awaitAsync(AsyncAssert.assertThrowsAsync(IllegalStateException.class, () -> lazy.value.getValueAsync()));
		});

	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testPollAsyncPrecancelled() {
	CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
	cancellationTokenSource.cancel();
	CompletableFuture<GenericParameterHelper> dequeueTask = queue.pollAsync(cancellationTokenSource.getToken());
	Assert.assertTrue(dequeueTask.isDone());
	CompletableFuture<Void> asyncTest = Async.awaitAsync(
		AsyncAssert.assertCancelsAsync(() -> dequeueTask),
		() -> {
			GenericParameterHelper enqueuedValue = new GenericParameterHelper(1);
			this.queue.add(enqueuedValue);

			Assert.assertEquals(1, this.queue.size());
			return Futures.completedNull();
		});

	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testPollAsyncCancelledBeforeComplete() {
	CompletableFuture<GenericParameterHelper> pollFuture = queue.pollAsync();
	Assert.assertFalse(pollFuture.isDone());

	Assert.assertTrue(pollFuture.cancel(true));

	try {
		thrown.expect(CancellationException.class);
		pollFuture.join();
	} finally {
		GenericParameterHelper addedValue = new GenericParameterHelper(1);
		queue.add(addedValue);

		Assert.assertEquals(1, this.queue.size());
	}
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testIsMainThreadBlockedFalseWhenSyncBlockingOtherThread() {
	CompletableFuture<Void> task = Futures.runAsync(() -> {
		getFactory().run(() -> {
			Assert.assertFalse(getContext().isMainThreadBlocked());
			return Async.awaitAsync(
				Async.yieldAsync(),
				() -> {
					Assert.assertFalse(getContext().isMainThreadBlocked());
					return Futures.completedNull();
				});
		});
	});

	task.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testSynchronizationContextNoAppliedToThreadPool_Supplier() {
	SynchronizationContext context = new SynchronizationContext() {
		// Sometimes SynchronizationContext.class is used to trigger special behavior, so we force it to extend the
		// base class.
	};

	Thread currentThread = Thread.currentThread();
	SynchronizationContext.setSynchronizationContext(context);
	CompletableFuture<Void> asyncTest = Futures.runAsync(() -> {
		Assert.assertNotSame(currentThread, Thread.currentThread());
		Assert.assertNotSame(context, SynchronizationContext.getCurrent());
		return Futures.completedNull();
	});

	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * Joining a minimal stage "by hand" works
 */
public void testMinimalCompletionStage_join_by_hand() {
    for (boolean createIncomplete : new boolean[] { true, false })
    for (Integer v1 : new Integer[] { 1, null })
{
    CompletableFuture<Integer> f = new CompletableFuture<>();
    CompletionStage<Integer> minimal = f.minimalCompletionStage();
    CompletableFuture<Integer> g = new CompletableFuture<>();
    if (!createIncomplete) assertTrue(f.complete(v1));
    minimal.thenAccept(x -> g.complete(x));
    if (createIncomplete) assertTrue(f.complete(v1));
    g.join();
    checkCompletedNormally(g, v1);
    checkCompletedNormally(f, v1);
    assertEquals(v1, join(minimal));
}}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * Verifies that continuations scheduled on a future will not be executed inline with the specified completing
 * action.
 *
 * @param antecedent The future to test.
 * @param completingAction The action that results in the synchronous completion of the future.
 */
protected static void verifyDoesNotInlineContinuations(@NotNull CompletableFuture<?> antecedent, @NotNull Runnable completingAction) {
	Requires.notNull(antecedent, "antecedent");
	Requires.notNull(completingAction, "completingAction");

	CompletableFuture<Void> completingActionFinished = new CompletableFuture<>();
	CompletableFuture<Void> continuation = antecedent.handle((result, exception) -> {
		try {
			return completingActionFinished.get(ASYNC_DELAY.toMillis(), TimeUnit.MILLISECONDS);
		} catch (InterruptedException | ExecutionException | TimeoutException ex) {
			throw new CompletionException(ex);
		}
	});

	completingAction.run();
	completingActionFinished.complete(null);

	// Rethrow the exception if it turned out it deadlocked.
	continuation.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testSetGetWithDelay() {
	GenericParameterHelper value = new GenericParameterHelper();
	asyncLocal.setValue(value);
	CompletableFuture<Void> asyncTest = Async.delayAsync(Duration.ofMillis(10)).thenRun(
		() -> {
			Assert.assertSame(value, asyncLocal.getValue());
			asyncLocal.setValue(null);
			Assert.assertNull(asyncLocal.getValue());
		});

	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testSetGetWithYield() {
	GenericParameterHelper value = new GenericParameterHelper();
	asyncLocal.setValue(value);
	CompletableFuture<Void> asyncTest = Async.awaitAsync(
		Async.yieldAsync(),
		() -> {
			Assert.assertSame(value, asyncLocal.getValue());
			asyncLocal.setValue(null);
			Assert.assertNull(asyncLocal.getValue());
			return Futures.completedNull();
		});

	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testAwaitable() {
	CompletableFuture<Void> task = Futures.runAsync(() -> {
		return Async.awaitAsync(this.event);
	});

	this.event.set();
	task.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void testGetValueAsyncWithCancellationTokenPreCanceled() {
	CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
	cancellationTokenSource.cancel();

	AsyncLazy<GenericParameterHelper> lazy = new AsyncLazy<>(() -> CompletableFuture.completedFuture(new GenericParameterHelper(5)));
	CompletableFuture<Void> asyncTest = Async.awaitAsync(
		AsyncAssert.assertCancelsAsync(() -> lazy.getValueAsync(cancellationTokenSource.getToken())),
		() -> {
			Assert.assertFalse("Value factory should not have been invoked for a pre-canceled token.", lazy.isValueCreated());
			return Futures.completedNull();
		});

	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * completeAsync with given executor completes exceptionally if
 * given supplier throws
 */
public void testCompleteAsync4() {
    CompletableFuture<Integer> f = new CompletableFuture<>();
    CFException ex = new CFException();
    ThreadExecutor executor = new ThreadExecutor();
    f.completeAsync(() -> { throw ex; }, executor);
    try {
        f.join();
        shouldThrow();
    } catch (CompletionException success) {}
    checkCompletedWithWrappedException(f, ex);
    assertEquals(1, executor.count.get());
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * This test is one part of verifying https://github.com/tunnelvisionlabs/java-threading/issues/11.
 */
@Test
public void testAwaitAsyncCompletedThenCancelledSupplier() {
	CompletableFuture<Void> cancellationFuture = new CompletableFuture<>();
	CompletableFuture<Void> asyncTest = Async.awaitAsync(
		Futures.completedNull(),
		() -> cancellationFuture);

	cancellationFuture.cancel(true);

	thrown.expect(CancellationException.class);
	asyncTest.join();
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
/**
 * consume returns a CompletableFuture that is done when
 * publisher completes
 */
public void testConsume() {
    AtomicInteger sum = new AtomicInteger();
    SubmissionPublisher<Integer> p = basicPublisher();
    CompletableFuture<Void> f =
        p.consume((Integer x) -> sum.getAndAdd(x.intValue()));
    int n = 20;
    for (int i = 1; i <= n; ++i)
        p.submit(i);
    p.close();
    f.join();
    assertEquals((n * (n + 1)) / 2, sum.get());
}
 

import java.util.concurrent.CompletableFuture; //导入方法依赖的package包/类
@Test
public void itExecutesReturnedExceptionalFuturesOnTheProvidedExecutor() {
  ExecutorService executorService = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder().setNameFormat("SmtpSessionTestExecutor").build());
  SmtpSession session = new SmtpSession(channel, responseHandler, CONFIG, executorService, SSL_ENGINE_SUPPLIER);

  CompletableFuture<SmtpClientResponse> future = session.send(SMTP_REQUEST);
  CompletableFuture<Boolean> assertionFuture = future.handle((r, e) -> {
    assertThat(Thread.currentThread().getName()).contains("SmtpSessionTestExecutor");
    return true;
  });

  responseFuture.completeExceptionally(new RuntimeException());
  assertionFuture.join();
}