Java Await类代码示例

import scala.concurrent.Await; //导入依赖的package包/类
@SuppressWarnings("checkstyle:IllegalCatch")
private void verifyActorReady(ActorRef actorRef) {
    // Sometimes we see messages go to dead letters soon after creation - it seems the actor isn't quite
    // in a state yet to receive messages or isn't actually created yet. This seems to happen with
    // actorSelection so, to alleviate it, we use an actorSelection and send an Identify message with
    // retries to ensure it's ready.

    Timeout timeout = new Timeout(100, TimeUnit.MILLISECONDS);
    Throwable lastError = null;
    Stopwatch sw = Stopwatch.createStarted();
    while (sw.elapsed(TimeUnit.SECONDS) <= 10) {
        try {
            ActorSelection actorSelection = system.actorSelection(actorRef.path().toString());
            Future<Object> future = Patterns.ask(actorSelection, new Identify(""), timeout);
            ActorIdentity reply = (ActorIdentity)Await.result(future, timeout.duration());
            Assert.assertNotNull("Identify returned null", reply.getRef());
            return;
        } catch (Exception | AssertionError e) {
            Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
            lastError = e;
        }
    }

    throw new RuntimeException(lastError);
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test
@SuppressWarnings("checkstyle:IllegalCatch")
public void testExecuteRemoteOperationAsync() {
    new JavaTestKit(getSystem()) {
        {
            ActorRef shardActorRef = getSystem().actorOf(Props.create(EchoActor.class));

            ActorRef shardManagerActorRef = getSystem().actorOf(MockShardManager.props(true, shardActorRef));

            ActorContext actorContext = new ActorContext(getSystem(), shardManagerActorRef,
                    mock(ClusterWrapper.class), mock(Configuration.class));

            ActorSelection actor = actorContext.actorSelection(shardActorRef.path());

            Future<Object> future = actorContext.executeOperationAsync(actor, "hello");

            try {
                Object result = Await.result(future, Duration.create(3, TimeUnit.SECONDS));
                assertEquals("Result", "hello", result);
            } catch (Exception e) {
                throw new AssertionError(e);
            }
        }
    };
}
 

import scala.concurrent.Await; //导入依赖的package包/类
public void cancelJob(JobID jobId) throws Exception {
    // this needs better support in the Flink Mini Cluster
    if (getCurrentlyRunningJobsJava().contains(jobId)) {
        final FiniteDuration timeout = timeout();
        final ActorGateway jobManagerGateway = getLeaderGateway(timeout);

        Future<Object> cancelFuture = jobManagerGateway.ask(
                new JobManagerMessages.CancelJob(jobId), timeout);

        Object result = Await.result(cancelFuture, timeout);
        if (!(result instanceof JobManagerMessages.CancellationSuccess)) {
            throw new Exception("Cancellation failed");
        }
    } else {
        throw new IllegalStateException("Job is not running");
    }
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test
public void testPersistentActorWIthIgnite() throws Exception {
    ActorRef actorRef = actorSystem.actorOf(Props.create(IgnitePersistentTestActor.class, "1"));
    actorRef.tell("+a", ActorRef.noSender());
    actorRef.tell("+b", ActorRef.noSender());
    actorRef.tell("+c", ActorRef.noSender());
    actorRef.tell("throw", ActorRef.noSender());

    Future<Object> future = Patterns.ask(actorRef, "-b", 1000);
    Await.result(future, Duration.create(1, TimeUnit.SECONDS));

    IgniteCache<Object, Object> cache = ignite.getOrCreateCache("akka-journal");
    Assert.assertEquals(cache.size(), 4);

    actorSystem.actorSelection("akka://test/user/**").tell("!!!", ActorRef.noSender());

    Await.result(actorSystem.terminate(), Duration.create(1, TimeUnit.SECONDS));
}
 

import scala.concurrent.Await; //导入依赖的package包/类
private void sendShutDown(final ActorRef actor) throws Exception {
    testLog.info("sendShutDown for {} starting", actor.path());

    FiniteDuration duration = FiniteDuration.create(5, TimeUnit.SECONDS);
    Future<Boolean> stopFuture = Patterns.gracefulStop(actor, duration, Shutdown.INSTANCE);

    Boolean stopped = Await.result(stopFuture, duration);
    assertEquals("Stopped", Boolean.TRUE, stopped);

    testLog.info("sendShutDown for {} ending", actor.path());
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test
public void testGetExistingYangTextSchemaSource() throws Exception {
    String source = "Test source.";
    YangTextSchemaSource schemaSource = YangTextSchemaSource.delegateForByteSource(
            ID, ByteSource.wrap(source.getBytes()));
    Mockito.when(mockedLocalRepository.getSchemaSource(ID, YangTextSchemaSource.class)).thenReturn(
            Futures.immediateCheckedFuture(schemaSource));

    Future<YangTextSchemaSourceSerializationProxy> retrievedSourceFuture =
            remoteRepository.getYangTextSchemaSource(ID);
    assertTrue(retrievedSourceFuture.isCompleted());
    YangTextSchemaSource resultSchemaSource = Await.result(retrievedSourceFuture,
            Duration.Zero()).getRepresentation();
    assertEquals(resultSchemaSource.getIdentifier(), schemaSource.getIdentifier());
    assertArrayEquals(resultSchemaSource.read(), schemaSource.read());
}
 

import scala.concurrent.Await; //导入依赖的package包/类
private void sendRegistrationRequests() {
    for (Map.Entry<String, Boolean> entry : notifierRegistrationStatus.entrySet()) {
        if (!entry.getValue()) {
            try {
                LOG.debug("{} registering with {}", getSelf().path().toString(), entry.getKey());
                ActorRef notifier = Await.result(
                    getContext().actorSelection(entry.getKey()).resolveOne(duration), duration);

                notifier.tell(new RegisterRoleChangeListener(), getSelf());

            } catch (Exception e) {
                LOG.error("ERROR!! Unable to send registration request to notifier {}", entry.getKey());
            }
        }
    }
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@SuppressWarnings("checkstyle:IllegalCatch")
private List<DataTreeListenerInfo> getListenerActorsInfo(Collection<ActorSelection> actors) {
    final Timeout timeout = new Timeout(20, TimeUnit.SECONDS);
    final List<Future<Object>> futureList = new ArrayList<>(actors.size());
    for (ActorSelection actor: actors) {
        futureList.add(Patterns.ask(actor, GetInfo.INSTANCE, timeout));
    }

    try {
        final List<DataTreeListenerInfo> listenerInfoList = new ArrayList<>();
        Await.result(Futures.sequence(futureList, ExecutionContext.Implicits$.MODULE$.global()),
                timeout.duration()).forEach(obj -> listenerInfoList.add((DataTreeListenerInfo) obj));
        return listenerInfoList;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test(expected = ReadFailedException.class)
public void testNegativeExistsWithReadWriteTransactionClosed() throws Exception {

    final ActorRef shard = createShard();
    final Props props = ShardTransaction.props(RW, STORE.newReadWriteTransaction(nextTransactionId()), shard,
            datastoreContext, shardStats);

    final TestActorRef<ShardTransaction> subject = TestActorRef.create(getSystem(), props,
            "testNegativeExistsWithReadWriteTransactionClosed");

    Future<Object> future = akka.pattern.Patterns.ask(subject,
            new DataExists(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION), 3000);
    Await.result(future, Duration.create(3, TimeUnit.SECONDS));

    subject.underlyingActor().getDOMStoreTransaction().abortFromTransactionActor();

    future = akka.pattern.Patterns.ask(subject,
            new DataExists(YangInstanceIdentifier.EMPTY, DataStoreVersions.CURRENT_VERSION), 3000);
    Await.result(future, Duration.create(3, TimeUnit.SECONDS));
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test public void bodySuccess200() throws Exception {
  server.enqueue(new MockResponse().setBody("Hi"));

  Future<String> future = service.body();
  String result = Await.result(future, Duration.create(5, SECONDS));
  assertThat(result).isEqualTo("Hi");
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test public void bodySuccess404() {
  server.enqueue(new MockResponse().setResponseCode(404));

  Future<String> future = service.body();
  try {
    Await.result(future, Duration.create(5, SECONDS));
    fail();
  } catch (Exception e) {
    assertThat(e)
        .isInstanceOf(HttpException.class) // Required for backwards compatibility.
        .isInstanceOf(retrofit2.HttpException.class)
        .hasMessage("HTTP 404 Client Error");
  }
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test public void bodyFailure() {
  server.enqueue(new MockResponse().setSocketPolicy(DISCONNECT_AFTER_REQUEST));

  Future<String> future = service.body();
  try {
    Await.result(future, Duration.create(5, SECONDS));
    fail();
  } catch (Exception e) {
    assertThat(e).isInstanceOf(IOException.class);
  }
}
 

import scala.concurrent.Await; //导入依赖的package包/类
private void stopAfterJob(ClusterClient client, JobID jobID) {
  Preconditions.checkNotNull(jobID, "The job id must not be null");
  try {
    Future<Object> replyFuture =
        client.getJobManagerGateway().ask(
            new ShutdownClusterAfterJob(jobID),
            AKKA_TIMEOUT);
    Await.ready(replyFuture, AKKA_TIMEOUT);
  } catch (Exception e) {
    throw new RuntimeException("Unable to tell application master to stop"
        + " once the specified job has been finished", e);
  }
}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Test
public void happyPathWOSales() throws Exception {
	
	// Given
	final Integer bookId = 1000;
	
	final Book expectedBook = srvBookCheck.getBook(bookId).getValue();

	final List<Chapter> expectedChapters = expectedBook.getChapters().stream()
			.map(s -> srvChapterCheck.getChapter(s).getValue())
			.collect(Collectors.toList());
	
	final Author expectedAuthor = srvAuthorCheck.getAuthor( expectedBook.getIdAuthor() ).getValue();

	// When
	final Future<Either<Error, Summary>> summaryFu = srvSummary
			.getSummary(bookId);
	
	final Either<Error, Summary> res = Await.result(summaryFu, Duration.apply(100, TimeUnit.MILLISECONDS));

	// Then
	final Summary summary = res.right().get();

	assertEquals( expectedBook, summary.getBook() );
	assertEquals( false, summary.getSales().isPresent() );
	assertEquals( expectedAuthor, summary.getAuthor() );
	assertEquals( expectedChapters, summary.getChapter());

}
 

import scala.concurrent.Await; //导入依赖的package包/类
@Benchmark
public Void ensureConstN() throws Exception {
  Future<Void> f = constVoidFuture;
  for (int i = 0; i < N.n; i++)
    f.transform(ensureF, ec);
  return Await.result(f, inf);
}