Java Futures.addCallback方法代码示例

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public ListenableFuture<Boolean> validate() {
    LOG.debug("Validating transaction for shard {}", shardRoot);

    checkTransactionReadied();
    final List<ListenableFuture<Boolean>> futures =
            cohorts.stream().map(DOMStoreThreePhaseCommitCohort::canCommit).collect(Collectors.toList());
    final SettableFuture<Boolean> ret = SettableFuture.create();

    Futures.addCallback(Futures.allAsList(futures), new FutureCallback<List<Boolean>>() {
        @Override
        public void onSuccess(final List<Boolean> result) {
            ret.set(true);
        }

        @Override
        public void onFailure(final Throwable throwable) {
            ret.setException(throwable);
        }
    }, MoreExecutors.directExecutor());

    return ret;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@VisibleForTesting
List<ListenableFuture<RequestVoteResponse>> sendRequests(final RaftStateContext ctx) {

    RequestVote request = RequestVote.newBuilder().setTerm(log.currentTerm()).setCandidateId(log.self().toString()).setLastLogIndex(log.lastLogIndex()).setLastLogTerm(log.lastLogTerm()).build();

    List<ListenableFuture<RequestVoteResponse>> responses = Lists.newArrayList();
    for (Replica replica : log.members()) {
        ListenableFuture<RequestVoteResponse> response = client.requestVote(replica, request);
        Futures.addCallback(response, new FutureCallback<RequestVoteResponse>() {
            @Override
            public void onSuccess(@Nullable RequestVoteResponse result) {
                checkTermOnResponse(ctx, result);
            }

            @Override
            public void onFailure(Throwable t) {
            }
        });
        responses.add(response);
    }

    return responses;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
static <KEY, RESULT> QuorumCall<KEY, RESULT> create(
    Map<KEY, ? extends ListenableFuture<RESULT>> calls) {
  final QuorumCall<KEY, RESULT> qr = new QuorumCall<KEY, RESULT>();
  for (final Entry<KEY, ? extends ListenableFuture<RESULT>> e : calls.entrySet()) {
    Preconditions.checkArgument(e.getValue() != null,
        "null future for key: " + e.getKey());
    Futures.addCallback(e.getValue(), new FutureCallback<RESULT>() {
      @Override
      public void onFailure(Throwable t) {
        qr.addException(e.getKey(), t);
      }

      @Override
      public void onSuccess(RESULT res) {
        qr.addResult(e.getKey(), res);
      }
    });
  }
  return qr;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public ListenableFuture<Void> prepare() {
    LOG.debug("Preparing transaction for shard {}", shardRoot);

    checkTransactionReadied();
    final List<ListenableFuture<Void>> futures =
            cohorts.stream().map(DOMStoreThreePhaseCommitCohort::preCommit).collect(Collectors.toList());
    final SettableFuture<Void> ret = SettableFuture.create();

    Futures.addCallback(Futures.allAsList(futures), new FutureCallback<List<Void>>() {
        @Override
        public void onSuccess(final List<Void> result) {
            ret.set(null);
        }

        @Override
        public void onFailure(final Throwable throwable) {
            ret.setException(throwable);
        }
    }, MoreExecutors.directExecutor());

    return ret;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public String load(final Object o) throws Exception {

    ListenableFuture<String> future = lex.submit(() -> {
        String result = toolTipsGenerator.getToolTipText(o);

        getCache().invalidate(o);
        getCache().put(o, result);

        return result;
    });
    Futures.addCallback(future, this);

    return Labels.LOADING;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
default void onLoadKey(Runnable runnable) {
    Futures.addCallback(getMasterPassword(), new FutureCallback<String>() {
        @Override
        public void onSuccess(@Nullable String result) {
            runnable.run();
        }

        @Override
        public void onFailure(Throwable t) {
            LOGGER.error("failed to run callback " + runnable.toString() + " due to unexpected error while waiting for keyfile: ", t);
        }
    });
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public void put(Collection<SinkRecord> sinkRecords) {

	// If KinesisProducers cannot write to Kinesis Streams (because of
	// connectivity issues, access issues
	// or misconfigured shards we will pause consumption of messages till
	// backlog is cleared

	validateOutStandingRecords();

	String partitionKey;
	for (SinkRecord sinkRecord : sinkRecords) {

		ListenableFuture<UserRecordResult> f;
		// Kinesis does not allow empty partition key
		if (sinkRecord.key() != null && !sinkRecord.key().toString().trim().equals("")) {
			partitionKey = sinkRecord.key().toString().trim();
		} else {
			partitionKey = Integer.toString(sinkRecord.kafkaPartition());
		}

		if (singleKinesisProducerPerPartition)
			f = addUserRecord(producerMap.get(sinkRecord.kafkaPartition() + "@" + sinkRecord.topic()), streamName,
					partitionKey, usePartitionAsHashKey, sinkRecord);
		else
			f = addUserRecord(kinesisProducer, streamName, partitionKey, usePartitionAsHashKey, sinkRecord);

		Futures.addCallback(f, callback);

	}
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
public JobCollectContext(final CollectPhase collectPhase,
                         MapSideDataCollectOperation collectOperation,
                         String localNodeId,
                         RamAccountingContext queryPhaseRamAccountingContext,
                         final RowReceiver rowReceiver,
                         SharedShardContexts sharedShardContexts) {
    super(collectPhase.executionPhaseId(), LOGGER);
    this.collectPhase = collectPhase;
    this.collectOperation = collectOperation;
    this.queryPhaseRamAccountingContext = queryPhaseRamAccountingContext;
    this.sharedShardContexts = sharedShardContexts;

    listenableRowReceiver = RowReceivers.listenableRowReceiver(rowReceiver);
    Futures.addCallback(listenableRowReceiver.finishFuture(), new FutureCallback<Void>() {
        @Override
        public void onSuccess(@Nullable Void result) {
            close();
        }

        @Override
        public void onFailure(@Nonnull Throwable t) {
            closeDueToFailure(t);
        }
    });
    this.rowReceiver = listenableRowReceiver;
    this.threadPoolName = threadPoolName(collectPhase, localNodeId);
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
public ListenableFuture<FullHttpResponse> execute() throws URISyntaxException {
  Preconditions.checkState(request != null);
  final SettableFuture<FullHttpResponse> error = SettableFuture.create();
  final SettableFuture<FullHttpResponse> response = SettableFuture.create();
  final ListenableFuture<ChannelFuture> connectFuture =
      connect(XUrl.getInetSocket(uri), client.getBootstrap(), buildRetryLoop());

  Futures.addCallback(
      connectFuture,
      new FutureCallback<ChannelFuture>() {
        @Override
        public void onSuccess(ChannelFuture result) {
          try {
            Channel channel = result.await().channel();
            channel.writeAndFlush(request);

            HttpResponseHandler responseHandler =
                (HttpResponseHandler) channel.pipeline().get("responseHandler");
            response.setFuture(responseHandler.getResponse());
          } catch (InterruptedException e) {
            response.cancel(true);
            error.setException(e);
          }
        }

        @Override
        public void onFailure(Throwable t) {
          response.cancel(true);
          error.setException(t);
        }
      });

  if (response.isCancelled()) {
    return error;
  } else {
    return response;
  }
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public void onCarBought(CarBought notification) {

  final CarPersonBuilder carPersonBuilder = new CarPersonBuilder();
  carPersonBuilder.setCarId(notification.getCarId());
  carPersonBuilder.setPersonId(notification.getPersonId());
  CarPersonKey key = new CarPersonKey(notification.getCarId(), notification.getPersonId());
  carPersonBuilder.setKey(key);
  final CarPerson carPerson = carPersonBuilder.build();

  LOG.info("Car bought, adding car-person entry: [{}]", carPerson);

  InstanceIdentifier<CarPerson> carPersonIId =
      InstanceIdentifier.<CarPeople>builder(CarPeople.class).child(CarPerson.class, carPerson.getKey()).build();


  WriteTransaction tx = dataProvider.newWriteOnlyTransaction();
  tx.put(LogicalDatastoreType.CONFIGURATION, carPersonIId, carPerson, true);

  Futures.addCallback(tx.submit(), new FutureCallback<Void>() {
    @Override
    public void onSuccess(final Void result) {
      LOG.info("Successfully added car-person entry: [{}]", carPerson);
    }

    @Override
    public void onFailure(final Throwable t) {
      LOG.error(String.format("Failed to add car-person entry: [%s]", carPerson), t);
    }
  });

}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
public ProjectorChainContext(int id,
                             String name,
                             UUID jobId,
                             ProjectorFactory projectorFactory,
                             List<Projection> projections,
                             RowReceiver rowReceiver,
                             RamAccountingContext ramAccountingContext) {
    super(id, LOGGER);
    this.name = name;
    ListenableRowReceiver listenableRowReceiver = RowReceivers.listenableRowReceiver(rowReceiver);
    Futures.addCallback(listenableRowReceiver.finishFuture(), new FutureCallback<Void>() {
        @Override
        public void onSuccess(@Nullable Void result) {
            ProjectorChainContext.this.close(null);
        }

        @Override
        public void onFailure(@Nonnull Throwable t) {
            ProjectorChainContext.this.close(t);
        }
    });
    projectorChain = FlatProjectorChain.withAttachedDownstream(
            projectorFactory,
            ramAccountingContext,
            projections,
            listenableRowReceiver,
            jobId
    );
    this.rowReceiver = projectorChain.firstProjector();
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public FluentFuture<V> addCallback(FutureCallback<V> callback) {
  Futures.addCallback(this, callback, executor);
  return this;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
/** Track the timestamp of the event for determining watermark values until it has been sent or dropped. */
public void trackTimestamp(ListenableFuture<UserRecordResult> f, TripEvent event) {
  Futures.addCallback(f, new RemoveTimestampCallback(event));
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public void getDevice(DeviceId deviceId, PluginCallback<Device> callback) {
  ListenableFuture<Device> deviceFuture = pluginCtx.deviceService.findDeviceByIdAsync(deviceId);
  Futures.addCallback(deviceFuture, getCallback(callback, v -> v));
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public RedFuture addSuccessCallback(Executor executor, EmptyCallback callback) {
    Futures.addCallback(_settableFuture, safeCallback(t -> callback.call(), null), executor);
    return this;
}