Java Future类代码示例

import scala.concurrent.Future; //导入依赖的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.Future; //导入依赖的package包/类
public static void verifyShardState(final AbstractDataStore datastore, final String shardName,
        final Consumer<OnDemandShardState> verifier) throws Exception {
    ActorContext actorContext = datastore.getActorContext();

    Future<ActorRef> future = actorContext.findLocalShardAsync(shardName);
    ActorRef shardActor = Await.result(future, Duration.create(10, TimeUnit.SECONDS));

    AssertionError lastError = null;
    Stopwatch sw = Stopwatch.createStarted();
    while (sw.elapsed(TimeUnit.SECONDS) <= 5) {
        OnDemandShardState shardState = (OnDemandShardState)actorContext
                .executeOperation(shardActor, GetOnDemandRaftState.INSTANCE);

        try {
            verifier.accept(shardState);
            return;
        } catch (AssertionError e) {
            lastError = e;
            Uninterruptibles.sleepUninterruptibly(50, TimeUnit.MILLISECONDS);
        }
    }

    throw lastError;
}
 

import scala.concurrent.Future; //导入依赖的package包/类
/**
  Performs a CreateTransaction try async.
 */
private void tryCreateTransaction() {
    LOG.debug("Tx {} Primary shard {} found - trying create transaction", getIdentifier(),
            primaryShardInfo.getPrimaryShardActor());

    Object serializedCreateMessage = new CreateTransaction(getIdentifier(), getTransactionType().ordinal(),
                primaryShardInfo.getPrimaryShardVersion()).toSerializable();

    Future<Object> createTxFuture = getActorContext().executeOperationAsync(
            primaryShardInfo.getPrimaryShardActor(), serializedCreateMessage, createTxMessageTimeout);

    createTxFuture.onComplete(new OnComplete<Object>() {
        @Override
        public void onComplete(Throwable failure, Object response) {
            onCreateTransactionComplete(failure, response);
        }
    }, getActorContext().getClientDispatcher());
}
 

import scala.concurrent.Future; //导入依赖的package包/类
@Test public void responseType() {
  Type bodyClass = new TypeToken<Future<String>>() {}.getType();
  assertThat(factory.get(bodyClass, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(String.class);
  Type bodyWildcard = new TypeToken<Future<? extends String>>() {}.getType();
  assertThat(factory.get(bodyWildcard, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(String.class);
  Type bodyGeneric = new TypeToken<Future<List<String>>>() {}.getType();
  assertThat(factory.get(bodyGeneric, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(new TypeToken<List<String>>() {}.getType());
  Type responseClass = new TypeToken<Future<Response<String>>>() {}.getType();
  assertThat(factory.get(responseClass, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(String.class);
  Type responseWildcard = new TypeToken<Future<Response<? extends String>>>() {}.getType();
  assertThat(factory.get(responseWildcard, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(String.class);
  Type resultClass = new TypeToken<Future<Response<String>>>() {}.getType();
  assertThat(factory.get(resultClass, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(String.class);
  Type resultWildcard = new TypeToken<Future<Response<? extends String>>>() {}.getType();
  assertThat(factory.get(resultWildcard, NO_ANNOTATIONS, retrofit).responseType())
      .isEqualTo(String.class);
}
 

import scala.concurrent.Future; //导入依赖的package包/类
private synchronized void performRegistration(ActorRef shard) {
    if (isClosed()) {
        return;
    }
    cohortRegistry = shard;
    Future<Object> future =
            Patterns.ask(shard, new DataTreeCohortActorRegistry.RegisterCohort(subtree, actor), TIMEOUT);
    future.onComplete(new OnComplete<Object>() {

        @Override
        public void onComplete(Throwable failure, Object val) {
            if (failure != null) {
                LOG.error("Unable to register {} as commit cohort", getInstance(), failure);
            }
            if (isClosed()) {
                removeRegistration();
            }
        }

    }, actorContext.getClientDispatcher());
}
 

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

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

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

    Future<Object> future = akka.pattern.Patterns.ask(subject,
            new ReadData(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 ReadData(YangInstanceIdentifier.EMPTY,
            DataStoreVersions.CURRENT_VERSION), 3000);
    Await.result(future, Duration.create(3, TimeUnit.SECONDS));
}
 

import scala.concurrent.Future; //导入依赖的package包/类
private void doRegistration(ActorRef shard, final YangInstanceIdentifier path,
        DataChangeScope scope) {

    Future<Object> future = actorContext.executeOperationAsync(shard,
            new RegisterChangeListener(path, dataChangeListenerActor, scope,
                listener instanceof ClusteredDOMDataChangeListener),
            actorContext.getDatastoreContext().getShardInitializationTimeout());

    future.onComplete(new OnComplete<Object>() {
        @Override
        public void onComplete(Throwable failure, Object result) {
            if (failure != null) {
                LOG.error("Failed to register DataChangeListener {} at path {}",
                        listener, path.toString(), failure);
            } else {
                RegisterDataTreeNotificationListenerReply reply = (RegisterDataTreeNotificationListenerReply)result;
                setListenerRegistrationActor(actorContext.actorSelection(
                        reply.getListenerRegistrationPath()));
            }
        }
    }, actorContext.getClientDispatcher());
}
 

import scala.concurrent.Future; //导入依赖的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.Future; //导入依赖的package包/类
Future<ActorSelection> readyTransaction() {
    // avoid the creation of a promise and a TransactionOperation
    if (transactionContext != null) {
        return transactionContext.readyTransaction();
    }

    final Promise<ActorSelection> promise = Futures.promise();
    enqueueTransactionOperation(new TransactionOperation() {
        @Override
        public void invoke(TransactionContext newTransactionContext) {
            promise.completeWith(newTransactionContext.readyTransaction());
        }
    });

    return promise.future();
}
 

import scala.concurrent.Future; //导入依赖的package包/类
@Override
public Future<Long> doAsyncReadHighestSequenceNr(String persistenceId, long fromSequenceNr) {
    return Futures.future(() -> {
        if (log.isDebugEnabled()) {
            log.debug("doAsyncReadHighestSequenceNr '{}' - {}", persistenceId, fromSequenceNr);
        }
        if (sequenceNumberTrack.containsKey(persistenceId)) {
            long highestSequenceNr = sequenceNumberTrack.get(persistenceId);
            if (highestSequenceNr != 0) {
                if (log.isDebugEnabled()) {
                    log.debug("doAsyncReadHighestSequenceNr '{}' {} -> {}", persistenceId, fromSequenceNr, highestSequenceNr);
                }
                return highestSequenceNr;
            } else {
                if (log.isDebugEnabled()) {
                    log.debug("doAsyncReadHighestSequenceNr '{}' {} -> {}", persistenceId, fromSequenceNr, fromSequenceNr);
                }
                return fromSequenceNr;
            }
        }
        return fromSequenceNr;
    }, storage.getDispatcher());
}
 

import scala.concurrent.Future; //导入依赖的package包/类
Future<Object> initiateDirectCommit() {
    final Future<Object> messageFuture = initiateCommit(true);
    messageFuture.onComplete(new OnComplete<Object>() {
        @Override
        public void onComplete(final Throwable failure, final Object message) throws Throwable {
            if (failure != null) {
                LOG.error("Failed to prepare transaction {} on backend", transaction.getIdentifier(), failure);
                transactionAborted(transaction);
            } else if (CommitTransactionReply.isSerializedType(message)) {
                LOG.debug("Transaction {} committed successfully", transaction.getIdentifier());
                transactionCommitted(transaction);
            } else {
                LOG.error("Transaction {} resulted in unhandled message type {}, aborting", message.getClass());
                transactionAborted(transaction);
            }
        }
    }, actorContext.getClientDispatcher());

    return messageFuture;
}
 

import scala.concurrent.Future; //导入依赖的package包/类
@Override
public Future<Optional<SelectedSnapshot>> doLoadAsync(String persistenceId, SnapshotSelectionCriteria criteria) {
    return storage.execute(persistenceId, cache, (entityIdParam, cacheParam) -> {
        if (log.isDebugEnabled()) {
            log.debug("doLoadAsync '{}' {} {}", persistenceId, criteria.minSequenceNr(), criteria.toString());
        }
        try (QueryCursor<Cache.Entry<Long, SnapshotItem>> query = cache
                .query(new SqlQuery<Long, SnapshotItem>(SnapshotItem.class, "sequenceNr >= ? AND sequenceNr <= ? AND timestamp >= ? AND timestamp <= ? and persistenceId=?")
                        .setArgs(criteria.minSequenceNr(), criteria.maxSequenceNr(), criteria.minTimestamp(), criteria.maxTimestamp(), persistenceId))) {

            List<Cache.Entry<Long, SnapshotItem>> iterator = query.getAll();
            final Optional<Cache.Entry<Long, SnapshotItem>> max = iterator.stream().max((o1, o2) -> {
                if (o1.getValue().getSequenceNr() > o2.getValue().getSequenceNr()) {
                    return 1;
                } else if (o1.getValue().getTimestamp() > o2.getValue().getTimestamp()) {
                    return 1;
                } else {
                    return -1;
                }
            });
            return Optional.ofNullable(max.isPresent() ? convert(persistenceId, max.get().getValue()) : null);
        }
    });
}
 

import scala.concurrent.Future; //导入依赖的package包/类
public static DistributedEntityOwnershipService start(final ActorContext context,
        final EntityOwnerSelectionStrategyConfig strategyConfig) {
    ActorRef shardManagerActor = context.getShardManager();

    Configuration configuration = context.getConfiguration();
    Collection<MemberName> entityOwnersMemberNames = configuration.getUniqueMemberNamesForAllShards();
    CreateShard createShard = new CreateShard(new ModuleShardConfiguration(EntityOwners.QNAME.getNamespace(),
            "entity-owners", ENTITY_OWNERSHIP_SHARD_NAME, ModuleShardStrategy.NAME, entityOwnersMemberNames),
                    newShardBuilder(context, strategyConfig), null);

    Future<Object> createFuture = context.executeOperationAsync(shardManagerActor,
            createShard, MESSAGE_TIMEOUT);

    createFuture.onComplete(new OnComplete<Object>() {
        @Override
        public void onComplete(final Throwable failure, final Object response) {
            if (failure != null) {
                LOG.error("Failed to create {} shard", ENTITY_OWNERSHIP_SHARD_NAME, failure);
            } else {
                LOG.info("Successfully created {} shard", ENTITY_OWNERSHIP_SHARD_NAME);
            }
        }
    }, context.getClientDispatcher());

    return new DistributedEntityOwnershipService(context);
}
 

import scala.concurrent.Future; //导入依赖的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.Future; //导入依赖的package包/类
@VisibleForTesting
void executeLocalEntityOwnershipShardOperation(final Object message) {
    if (localEntityOwnershipShard == null) {
        Future<ActorRef> future = context.findLocalShardAsync(ENTITY_OWNERSHIP_SHARD_NAME);
        future.onComplete(new OnComplete<ActorRef>() {
            @Override
            public void onComplete(final Throwable failure, final ActorRef shardActor) {
                if (failure != null) {
                    LOG.error("Failed to find local {} shard", ENTITY_OWNERSHIP_SHARD_NAME, failure);
                } else {
                    localEntityOwnershipShard = shardActor;
                    executeEntityOwnershipShardOperation(localEntityOwnershipShard, message);
                }
            }
        }, context.getClientDispatcher());

    } else {
        executeEntityOwnershipShardOperation(localEntityOwnershipShard, message);
    }
}