Since Java 8, you can use CompletableFuture.supplyAsync to asynchronously run a task/method as the following example

@Test
public void supplyAsync() throws ExecutionException, InterruptedException {  
    CompletableFuture completableFuture = CompletableFuture.supplyAsync(() -> "Hello future!");
    assertThat(completableFuture.get()).isEqualTo("Hello future!");
The CompletableFuture.supplyAsync run asynchronously a Supplier functional interface which represented by the lambda expression () -> "Hello future!"
The completableFuture.get() blocks until the completableFuture is complete and return the result
Apart from using get(), you can also use its result to continuously execute other methods in the callbacks chain
Let's walk through this tutorial to see the examples in practice
Transform the result with thenApplyAsync callbacks
The thenApplyAsync takes and transforms the result returned from supplyAsync
@Test
public void thenApplyAsync() throws ExecutionException, InterruptedException {  
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Future");
    completableFuture = completableFuture.thenApplyAsync((s) -> s.concat(" is awesome!"));
    assertThat(completableFuture.get()).isEqualTo("Future is awesome!");
APIs in CompletableFuture may come in 3 forms: default synchronous execution, default asynchronous execution (name with Async suffix) and asynchronous execution with custom Executor. The default async uses ForkJoinPool.commonPool() to execute. The following gives you an example of using custom Executor
@Test
public void thenApplyAsyncWithExecutor() throws ExecutionException, InterruptedException {  
    ExecutorService executorService = Executors.newFixedThreadPool(2);
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Future", executorService);
    completableFuture = completableFuture.thenApplyAsync((s) -> s.concat(" is awesome!"), executorService);
    stop(executorService);
    assertThat(completableFuture.get()).isEqualTo("Future is awesome!");
Combine the results with thenComposeAsync and thenCombineAsync
The thenComposeAsync passes the result returned from one to another CompletableFuture
@Test
public void thenComposeAsync() throws ExecutionException, InterruptedException {  
    CompletableFuture<String> composedCompletableFuture = CompletableFuture
            .supplyAsync(() -> "Future")
            .thenComposeAsync(s -> CompletableFuture.supplyAsync(() -> s.concat(" is awesome!")));
    assertThat(composedCompletableFuture.get()).isEqualTo("Future is awesome!");
The thenCombineAsync combines the result of two independent CompletableFuture
@Test
public void thenCombineAsync() throws ExecutionException, InterruptedException {  
    CompletableFuture<String> completableFuture1 = CompletableFuture.supplyAsync(() -> "Future");
    CompletableFuture<String> completableFuture2 = CompletableFuture.supplyAsync(() -> " is awesome!");
    CompletableFuture<String> combinedCompletableFuture = completableFuture1.thenCombineAsync(completableFuture2, (s1, s2) -> s1.concat(s2));
    assertThat(combinedCompletableFuture.get()).isEqualTo("Future is awesome!");
Await completion of independent CompletableFutures
The allOf returns a new CompletableFuture<Void> which completed when all of the given CompletableFuture completed
@Test
public void allOf() {  
    CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> "Future");
    CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> " is awesome!");
    CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> "!");
    CompletableFuture<String>[] cfs = new CompletableFuture[]{cf1, cf2, cf3};
    CompletableFuture<Void> allCf = CompletableFuture.allOf(cfs);
    allCf.join();
    String result = Arrays.stream(cfs).map(CompletableFuture::join).collect(Collectors.joining());
    assertThat(result).isEqualTo("Future is awesome!!");
The anyOf returns a new CompletableFuture<Object> which completed when any of the given CompletableFuture completed
@Test
public void anyOf() throws ExecutionException, InterruptedException {  
    CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> "Future");
    CompletableFuture<String> cf2 = CompletableFuture.supplyAsync(() -> " is awesome!");
    CompletableFuture<String> cf3 = CompletableFuture.supplyAsync(() -> "!");
    CompletableFuture<Object> anyCf = CompletableFuture.anyOf(cf1, cf2, cf3);
    System.out.println(anyCf.get());
    assertThat(anyCf).isDone();
Complete the stage with thenAcceptAsync and thenRunAsync
The thenAcceptAsync accepts the result returned from this stage, passes it to the supplied Consumer function and returns a new CompletionStage<Void>
@Test
public void thenAcceptAsync() throws ExecutionException, InterruptedException {  
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Future");
    completableFuture = completableFuture.thenApplyAsync((s) -> s.concat(" is awesome!"));
    CompletableFuture<Void> procedureFuture = completableFuture.thenAcceptAsync(System.out::println);
    assertThat(procedureFuture.get()).isNull();
The thenRunAsync runs the supplied Runnable action when the stage completes normally and returns a new CompletionStage<Void>
@Test
public void thenRunAsync() throws ExecutionException, InterruptedException {  
    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> "Future");
    completableFuture = completableFuture.thenApplyAsync((s) -> s.concat(" is awesome!"));
    CompletableFuture<Void> procedureFuture = completableFuture.thenRunAsync(() -> System.out.println("!"));
    assertThat(procedureFuture.isDone()).isTrue();
    assertThat(procedureFuture.get()).isNull();
Conclusion
In this tutorial, we learned using CompletableFuture.supplyAsync to run asynchronously a method and attach thenApplyAsync, thenComposeAsync, thenCombineAsync, thenAcceptAsync, thenRunAsync to its callbacks chain. You can find the full source code as below