--- async methods ---
979253
public Future<T> getAsync(Object parentKey, ID id) throws IOException {
    Object key = mapper.toKey(parentKey, id);
    Future<?> future = supplier.readFuture(getCurrentTransaction(), mapper, key);
    return new EntityFuture<T>(mapper, future);
  }
1320164
@SafeVarargs
    public final ContinuableFuture<Boolean> asyncExists(final String query, final Object... parameters) {
        return asyncExecutor.execute(new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                return exists(query, parameters);
            }
        });
    }
245728
function(next) {
        var source = config.getSource(asset.source);

        async.parallel([
          getFromSource.bind(null, source, asset, fromVersion, config),
          getFromSource.bind(null, source, asset, toVersion, config)
        ], next);
      }
89655
public static void runAsyncTask(Object context, int asyncTaskId, Object... args) {
		
		if(!ProfileService.getInstance(context).isActive(context, Profile.THREADING)) {

			StringBuilder builder = new StringBuilder()
			.append("Async task with ID ")
			.append(asyncTaskId)
			.append("cannot be run since the threading profile is inactive.");
			
			Log.w("Async task cannot ", builder.toString());

			return;
		}
		
		TaskManagers.ASYNC.execute(context, asyncTaskId, args);
	}
1066253
private <T, S extends ISyncableData> void doSync(T caller, String... syncNames)
	{
		@SuppressWarnings("unchecked")
		ISyncHandler<T, S> handler = (ISyncHandler<T, S>) getHandler(caller);
		if (handler == null)
			return;

		S data = handler.getSyncData(caller);
		int indexes = getFieldIndexes(handler, syncNames);
		Map<String, Object> values = getFieldValues(caller, handler, syncNames);

		SyncerMessage.Packet<T, S> packet = new Packet<>(getHandlerId(caller.getClass()), data, indexes, values);

		handler.send(caller, packet);
	}
221288
function AsyncSubject() {
      __super__.call(this);
      this.isDisposed = false;
      this.isStopped = false;
      this.hasValue = false;
      this.observers = [];
      this.hasError = false;
    }
1296701
@Override
    public void await() throws InterruptedException {
        queueLock.lock();
        try {
            while(test()) {
                condition.await();
            }
        }
        finally {
            queueLock.unlock();
        }
    }
364713
public <R> BaasResult<R> await(int requestId) {
        Task<R> task = (Task<R>) liveAsyncs.get(requestId);
        if (task == null) {
            return null;
        } else if (task.result != null) {
            return task.result;
        } else {
            task.await();
            return task.result;
        }
    }
384703
public static void collect() {
        AsyncTask.execute(new Runnable() {
            @Override
            public void run() {
                devicePropertiesCollector.collect();
                appStateCollector.collect();
            }
        });
    }
1290471
@Override
    public java.util.concurrent.Future<ListSAMLProvidersResult> listSAMLProvidersAsync(
            com.amazonaws.handlers.AsyncHandler<ListSAMLProvidersRequest, ListSAMLProvidersResult> asyncHandler) {

        return listSAMLProvidersAsync(new ListSAMLProvidersRequest(), asyncHandler);
    }
1154271
private void waitForCompletion() {
        for (ListenableFuture<?> future : pendingTasks.values()) {
            try {
                future.get();
            } catch (InterruptedException | ExecutionException e) {
                LOG.error("[" + this + "] Error waiting for writes to complete: " + e.getMessage());
            }
        }
    }
682045
async function () {
    const oThis = this
    ;

    try {
      const highestBlock = await this.getChainHighestBlock();

      // return if nothing more to do.
      if (highestBlock - 6 <= oThis.lastProcessedBlock) return oThis.schedule();

      // consider case in which last block was not processed completely

      oThis.fromBlock = oThis.snmData.lastProcessedBlock + 1;
      oThis.toBlock = highestBlock - 6;

      const events = await oThis.completeContract.getPastEvents(
        oThis.EVENT_NAME,
        {fromBlock: oThis.fromBlock, toBlock: oThis.toBlock},
        function (error, logs) {
          if (error) logger.error('getPastEvents error:', error);
          logger.log('getPastEvents done from block:', oThis.fromBlock, 'to block:', oThis.toBlock);
        }
      );
      await oThis.processEventsArray(events);

      oThis.schedule();
    } catch (err) {
      logger.info('Exception got:', err);

      if (oThis.interruptSignalObtained) {
        logger.info('Exiting Process....');
        process.exit(1);
      } else {
        oThis.reInit();
      }

    }
  }
1344255
public void waitForAsyncFlush() {
    long numAdded = asyncBatchesAdded.get();

    synchronized (this) {
      while (numAdded > asyncBatchesProcessed) {
        try {
          wait();
        } catch (InterruptedException e) {
          throw new RuntimeException(e);
        }
      }
    }
  }
830211
public void asyncRequestWithSession(AsyncRequest asyncRequest, AsyncResponseCallback asyncResponseCallback) {
        doRequest.doRequest(asyncRequest, true, asyncResponseCallback);
    }
103026
@Override
    public <RequestType extends Request, ResponseType extends Response> Future<ResponseType> performAsync(String endpoint, RequestType request, Class<ResponseType> responseClass) throws HttpRosetteAPIException {
        throw new UnsupportedOperationException("Asynchronous operations are not yet supported");
    }
1332742
async function() {
    const oThis = this
    ;

    await new openSTStorage.TokenBalanceModel({
      ddb_service: ddbServiceObj,
      auto_scaling: autoScalingServiceObj,
      erc20_contract_address: oThis.erc20
    }).allocate();
  }
9284
@Override
    public java.util.concurrent.Future<ListTaskDefinitionsResult> listTaskDefinitionsAsync(
            com.amazonaws.handlers.AsyncHandler<ListTaskDefinitionsRequest, ListTaskDefinitionsResult> asyncHandler) {

        return listTaskDefinitionsAsync(new ListTaskDefinitionsRequest(), asyncHandler);
    }