Java Futures.get方法代码示例

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@Override
public FlowRuleEvent removeFlowRule(FlowEntry rule) {
    final DeviceId deviceId = rule.deviceId();
    NodeId master = mastershipService.getMasterFor(deviceId);

    if (Objects.equals(local, master)) {
        // bypass and handle it locally
        return removeFlowRuleInternal(rule);
    }

    if (master == null) {
        log.warn("Failed to removeFlowRule: No master for {}", deviceId);
        // TODO: revisit if this should be null (="no-op") or Exception
        return null;
    }

    log.trace("Forwarding removeFlowRule to {}, which is the master for device {}",
              master, deviceId);

    return Futures.get(clusterCommunicator.sendAndReceive(
                           rule,
                           REMOVE_FLOW_ENTRY,
                           SERIALIZER::encode,
                           SERIALIZER::decode,
                           master),
                       FLOW_RULE_STORE_TIMEOUT_MILLIS,
                       TimeUnit.MILLISECONDS,
                       RuntimeException.class);
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public MoveApplicationAcrossQueuesResponse moveApplicationAcrossQueues(
    MoveApplicationAcrossQueuesRequest request) throws YarnException {
  ApplicationId applicationId = request.getApplicationId();

  UserGroupInformation callerUGI;
  try {
    callerUGI = UserGroupInformation.getCurrentUser();
  } catch (IOException ie) {
    LOG.info("Error getting UGI ", ie);
    RMAuditLogger.logFailure("UNKNOWN", AuditConstants.MOVE_APP_REQUEST,
        "UNKNOWN", "ClientRMService" , "Error getting UGI",
        applicationId);
    throw RPCUtil.getRemoteException(ie);
  }

  RMApp application = this.rmContext.getRMApps().get(applicationId);
  if (application == null) {
    RMAuditLogger.logFailure(callerUGI.getUserName(),
        AuditConstants.MOVE_APP_REQUEST, "UNKNOWN", "ClientRMService",
        "Trying to move an absent application", applicationId);
    throw new ApplicationNotFoundException("Trying to move an absent"
        + " application " + applicationId);
  }

  if (!checkAccess(callerUGI, application.getUser(),
      ApplicationAccessType.MODIFY_APP, application)) {
    RMAuditLogger.logFailure(callerUGI.getShortUserName(),
        AuditConstants.MOVE_APP_REQUEST,
        "User doesn't have permissions to "
            + ApplicationAccessType.MODIFY_APP.toString(), "ClientRMService",
        AuditConstants.UNAUTHORIZED_USER, applicationId);
    throw RPCUtil.getRemoteException(new AccessControlException("User "
        + callerUGI.getShortUserName() + " cannot perform operation "
        + ApplicationAccessType.MODIFY_APP.name() + " on " + applicationId));
  }
  
  // Moves only allowed when app is in a state that means it is tracked by
  // the scheduler
  if (EnumSet.of(RMAppState.NEW, RMAppState.NEW_SAVING, RMAppState.FAILED,
      RMAppState.FINAL_SAVING, RMAppState.FINISHING, RMAppState.FINISHED,
      RMAppState.KILLED, RMAppState.KILLING, RMAppState.FAILED)
      .contains(application.getState())) {
    String msg = "App in " + application.getState() + " state cannot be moved.";
    RMAuditLogger.logFailure(callerUGI.getShortUserName(),
        AuditConstants.MOVE_APP_REQUEST, "UNKNOWN", "ClientRMService", msg);
    throw new YarnException(msg);
  }

  SettableFuture<Object> future = SettableFuture.create();
  this.rmContext.getDispatcher().getEventHandler().handle(
      new RMAppMoveEvent(applicationId, request.getTargetQueue(), future));
  
  try {
    Futures.get(future, YarnException.class);
  } catch (YarnException ex) {
    RMAuditLogger.logFailure(callerUGI.getShortUserName(),
        AuditConstants.MOVE_APP_REQUEST, "UNKNOWN", "ClientRMService",
        ex.getMessage());
    throw ex;
  }

  RMAuditLogger.logSuccess(callerUGI.getShortUserName(), 
      AuditConstants.MOVE_APP_REQUEST, "ClientRMService" , applicationId);
  MoveApplicationAcrossQueuesResponse response = recordFactory
      .newRecordInstance(MoveApplicationAcrossQueuesResponse.class);
  return response;
}
 

import com.google.common.util.concurrent.Futures; //导入方法依赖的package包/类
static void linkBlocks(DataNode datanode, File from, File to, int oldLV,
    HardLink hl) throws IOException {
  boolean upgradeToIdBasedLayout = false;
  // If we are upgrading from a version older than the one where we introduced
  // block ID-based layout AND we're working with the finalized directory,
  // we'll need to upgrade from the old flat layout to the block ID-based one
  if (oldLV > DataNodeLayoutVersion.Feature.BLOCKID_BASED_LAYOUT.getInfo().
      getLayoutVersion() && to.getName().equals(STORAGE_DIR_FINALIZED)) {
    upgradeToIdBasedLayout = true;
  }

  final ArrayList<LinkArgs> idBasedLayoutSingleLinks = Lists.newArrayList();
  linkBlocksHelper(from, to, oldLV, hl, upgradeToIdBasedLayout, to,
      idBasedLayoutSingleLinks);

  // Detect and remove duplicate entries.
  final ArrayList<LinkArgs> duplicates =
      findDuplicateEntries(idBasedLayoutSingleLinks);
  if (!duplicates.isEmpty()) {
    LOG.error("There are " + duplicates.size() + " duplicate block " +
        "entries within the same volume.");
    removeDuplicateEntries(idBasedLayoutSingleLinks, duplicates);
  }

  int numLinkWorkers = datanode.getConf().getInt(
      DFSConfigKeys.DFS_DATANODE_BLOCK_ID_LAYOUT_UPGRADE_THREADS_KEY,
      DFSConfigKeys.DFS_DATANODE_BLOCK_ID_LAYOUT_UPGRADE_THREADS);
  ExecutorService linkWorkers = Executors.newFixedThreadPool(numLinkWorkers);
  final int step = idBasedLayoutSingleLinks.size() / numLinkWorkers + 1;
  List<Future<Void>> futures = Lists.newArrayList();
  for (int i = 0; i < idBasedLayoutSingleLinks.size(); i += step) {
    final int iCopy = i;
    futures.add(linkWorkers.submit(new Callable<Void>() {
      @Override
      public Void call() throws IOException {
        int upperBound = Math.min(iCopy + step,
            idBasedLayoutSingleLinks.size());
        for (int j = iCopy; j < upperBound; j++) {
          LinkArgs cur = idBasedLayoutSingleLinks.get(j);
          NativeIO.link(cur.src, cur.dst);
        }
        return null;
      }
    }));
  }
  linkWorkers.shutdown();
  for (Future<Void> f : futures) {
    Futures.get(f, IOException.class);
  }
}