Create a Future object that asyncrhonously populates using the Common
ForkJoinPool from the user provided Supplier

@param s
Supplier to asynchronously populate results from
@return Future asynchronously populated from the Supplier
426022
public static <T> Future<T> of(final Supplier<T> s) {
        return Future.of(CompletableFuture.supplyAsync(s));
    }
1222325
@Override
    public java.util.concurrent.Future<ListSSHPublicKeysResult> listSSHPublicKeysAsync(
            com.amazonaws.handlers.AsyncHandler<ListSSHPublicKeysRequest, ListSSHPublicKeysResult> asyncHandler) {

        return listSSHPublicKeysAsync(new ListSSHPublicKeysRequest(), asyncHandler);
    }
590261
@Override
    public java.util.concurrent.Future<ListJobsResult> listJobsAsync(com.amazonaws.handlers.AsyncHandler<ListJobsRequest, ListJobsResult> asyncHandler) {

        return listJobsAsync(new ListJobsRequest(), asyncHandler);
    }
1221465
public static <T> Function0<T> memoizeSupplier(final Supplier<T> s) {
        AtomicReference value = new AtomicReference<>(
            UNSET);
        return ()->{
            Object val = value.get();
        if (val == UNSET) {
            synchronized (UNSET){
                if(value.get()==UNSET) {
                    val = s.get();
                    value.set(val);
                }
            }
        }

        return (T)val;
        };

    }
895012
public ServiceFuture<List<ServerInner>> listAsync(final ServiceCallback<List<ServerInner>> serviceCallback) {
        return ServiceFuture.fromResponse(listWithServiceResponseAsync(), serviceCallback);
    }
1199350
public static <T> Future<T> asyncRun(Callable<T> callable)
	{
		RunnableCallableFuture<T> future = new RunnableCallableFuture<T>(callable);

		future.asyncRun();

		return future;
	}
1335327
public static <T> T get(Future<T> future) {
    return get(future, 30, TimeUnit.SECONDS);
  }
1021090
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
            Executor executor) {
        return CompletableFuture
                .supplyAsync(handleSupplierWithException(supplier), executor);
    }
296294
public <T extends DataSource> FutureData<ManagedSource> create(String name, T source) {
        return updateOrCreate(name, source, null);
    }
1347887
public <T extends MwsObject> Future<T> callAsync(final MwsRequestType type,
            final MwsObject requestData) {
        return getExecutorService().submit(new Callable<T>() {
            @Override
            public T call() {
                return MwsConnection.this.call(type, requestData);
            }
        });
    }
301036
public Future<Boolean> requestConnectionToBroker() {
        FutureTask futureTask = new FutureTask(new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                boolean ok = false;
                try {
                    getConnection();
                    ok = true;
                } catch (JMSException e) {
                    LOGGER.warn("Error connecting to JMS", e);
                }
                return ok;
            }
        });
        reconnectorService.schedule(futureTask, 0, TimeUnit.SECONDS);
        return futureTask;
    }
424960
public <U> FutureStream<U> construct(final Stream<U> s) {

        return new FutureStreamImpl<U>(
                                           this, s);

    }
700417
@Override
    public java.util.concurrent.Future<ListKeysResult> listKeysAsync(com.amazonaws.handlers.AsyncHandler<ListKeysRequest, ListKeysResult> asyncHandler) {

        return listKeysAsync(new ListKeysRequest(), asyncHandler);
    }
967371
@Beta
  public Future<HttpResponse> executeAsync() {
    return executeAsync(
        Executors.newFixedThreadPool(1, new ThreadFactoryBuilder().setDaemon(true).build()));
  }
1354117
public static <A> Will<A> forFuture(Future<A> future) {
        return new Of<A>(JdkFutureAdapters.listenInPoolThread(future));
    }
908194
public static <T> ListenableFuture<T> future(final Async<T> async) {
        return executor().submit(async);
    }
1178241
@Override
    public java.util.concurrent.Future<ListStreamsResult> listStreamsAsync(String exclusiveStartStreamName) {

        return listStreamsAsync(new ListStreamsRequest().withExclusiveStartStreamName(exclusiveStartStreamName));
    }