XQA
Back to Java
2026-04-238 min read

Async Promises (Java)

Learn Async Promises (Java) step by step with clear examples and exercises.

Why This Matters

Async Promises are a crucial part of modern Java programming, enabling developers to write efficient, responsive, and scalable asynchronous code. By using Async Promises, you can improve performance, prevent blocking, reduce latency, and create more robust applications. Understanding Async Promises is essential for tackling complex problems, debugging intricate issues, and staying competitive in the job market.

Prerequisites

Before diving into Async Promises, it's essential to have a strong foundation in Java:

  1. Basic concepts (variables, data types, operators, loops, functions)
  2. Control structures (if-else, switch, try-catch)
  3. Classes and objects
  4. Exception handling
  5. Threads and multithreading
  6. Interfaces and lambda expressions
  7. Familiarity with Java 8 features such as Stream API and functional interfaces
  8. Understanding of synchronization and concurrency concepts, including locks, semaphores, and atomic variables
  9. Knowledge of Java's I/O operations (reading from files, network connections)

Core Concept

Async Promises are a part of the Java 8 library, specifically in the java.util.concurrent.CompletableFuture class. They represent an asynchronous operation that may produce a result or fail with an exception. CompletableFutures can be chained together to create intricate asynchronous workflows.

Creating Async Promises

To create an Async Promise, you need to use the CompletableFuture.supplyAsync() method, which accepts a Runnable or Callable object that represents the asynchronous operation. Here's an example:

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;

public class AsyncPromiseExample {
public static void main(String[] args) {
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
System.out.println("Running asynchronously!");
}, Executors.newSingleThreadExecutor());

future.whenComplete((result, exception) -> {
if (exception != null) {
exception.printStackTrace();
} else {
System.out.println("Asynchronous operation completed successfully.");
}
});
}
}

In this example, we create an Async Promise using CompletableFuture.runAsync(). The Runnable task simply prints a message to the console. We also use the whenComplete() method to handle the result or exception once the operation is completed.

Chaining Async Promises

Async Promises can be chained together to create intricate asynchronous workflows. Here's an example:

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class AsyncPromiseChainExample {
public static void main(String[] args) throws InterruptedException {
CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
TimeUnit.SECONDS.sleep(2);
return 42;
}, Executors.newSingleThreadExecutor());

CompletableFuture<String> future2 = future1.thenApplyAsync((result) -> {
return "The answer to life, the universe, and everything is: " + result;
}, Executors.newSingleThreadExecutor());

CompletableFuture<Void> future3 = future2.whenComplete((result, exception) -> {
if (exception != null) {
exception.printStackTrace();
} else {
System.out.println(result);
}
});
}
}

In this example, we create two Async Promises: future1 and future2. future1 delays for 2 seconds and returns the number 42. future2 is chained to future1, applying a function that converts the result into a string. Finally, future3 handles the result or exception once both operations are completed.

Advanced Concepts

CompletableFuture methods

  • thenAccept(): Accepts an Action to perform when the CompletableFuture completes normally
  • thenRun(): Runs a Runnable task when the CompletableFuture completes, whether normally or exceptionally
  • thenApplyAsync(): Applies a Function to the result of a CompletableFuture and returns another CompletableFuture that represents the result of the applied function
  • exceptionally(): Provides a supplier of a result in case of an exception
  • handle(): Combines whenComplete(), thenAccept(), and exceptionally() into a single method
  • allOf(): Waits for all given CompletableFutures to complete
  • anyOf(): Completes when any of the given CompletableFutures completes
  • completedFuture(): Creates a completed CompletableFuture with a specified value or exception

Worked Example

Let's create an Async Promise that downloads a web page and prints its content:

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;

public class AsyncPromiseWorkedExample {
public static void main(String[] args) throws Exception {
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
URL url = new URL("https://www.example.com");
BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
StringBuilder content = new StringBuilder();
String line;
while ((line = reader.readLine()) != null) {
content.append(line);
}
return content.toString();
}, Executors.newSingleThreadExecutor());

future.whenComplete((result, exception) -> {
if (exception != null) {
exception.printStackTrace();
} else {
System.out.println(result);
}
});
}
}

In this example, we create an Async Promise that downloads the web page of "https://www.example.com". The Runnable task reads the content line by line and concatenates it into a StringBuilder. Once the operation is completed, the result (the web page content) is printed to the console.

Common Mistakes

  1. Forgetting to handle exceptions: Always use whenComplete(), handle(), or exceptionally() methods to handle exceptions that might occur during asynchronous operations.
  2. Not using ExecutorService for supplying tasks: Always create an ExecutorService when using CompletableFuture.supplyAsync(). Using a fixed thread pool ensures that the number of threads is limited and can prevent resource exhaustion.
  3. Chaining Async Promises incorrectly: Make sure to chain Async Promises in the correct order, and use appropriate methods like thenAccept(), thenRun(), or thenApplyAsync() depending on your needs.
  4. Ignoring results: If you're chaining Async Promises to perform a series of asynchronous operations, don't forget to handle the result of each operation in the next step.
  5. Not canceling Async Promises: If an asynchronous operation is no longer needed, make sure to cancel the corresponding Async Promise using the cancel() method to avoid resource leaks.
  6. Misusing CompletableFuture methods: Be aware of the differences between various CompletableFuture methods and use them appropriately for your specific needs.
  7. Not considering thread safety: Be mindful of potential issues related to concurrent access and synchronization when working with multiple threads.
  8. Ignoring timeouts: Set appropriate timeouts on Async Promises to prevent long-running operations from blocking other tasks or causing application instability.
  9. Not properly handling exceptions in chained promises: Make sure to handle exceptions that might occur during any step of the chain, not just at the end.
  10. Creating too many threads: Be careful not to create an excessive number of threads when using CompletableFutures, as this can lead to resource exhaustion and poor performance.

Practice Questions

  1. Write an Async Promise that reads a file and prints its content.
  2. Chain two Async Promises to download two web pages and print their combined content.
  3. Create an Async Promise that performs a network request using the HttpURLConnection class and returns the response code.
  4. Write an Async Promise that sorts an array asynchronously using the QuickSort algorithm.
  5. Implement a simple asynchronous chat application using Async Promises.
  6. Create an Async Promise that downloads multiple files concurrently and saves them to disk.
  7. Write an Async Promise that validates user credentials against a remote API and returns a boolean indicating whether the login was successful.
  8. Chain three or more Async Promises to perform complex asynchronous operations, such as fetching data from multiple APIs and processing it before returning the final result.
  9. Implement a simple web crawler that downloads the HTML content of multiple web pages and extracts specific information (e.g., links, titles) using Async Promises.
  10. Write an Async Promise that performs a long-running computation (e.g., prime number checker, Fibonacci sequence generator) and returns the result once it's completed, allowing other tasks to continue without waiting.

FAQ

  1. What is the difference between CompletableFuture and Future in Java?

CompletableFuture extends Future, but it can represent an asynchronous operation that may produce a result or fail with an exception, while a regular Future only represents an asynchronous operation that will eventually complete.

  1. Can I chain more than two Async Promises in Java?

Yes, you can chain any number of Async Promises in Java by using the appropriate methods like thenAccept(), thenRun(), or thenApplyAsync().

  1. How do I cancel an Async Promise in Java?

You can cancel an Async Promise in Java by calling the cancel() method on it. If the operation is still running, it will be interrupted and may throw an ExecutionException.

  1. What happens if an exception occurs during an asynchronous operation chained with other Async Promises?

If an exception occurs during an asynchronous operation that's part of a chain, it will propagate through the chain using the whenComplete() or handle() methods you've defined for handling exceptions.

  1. What are some best practices when using Async Promises in Java?

Some best practices include: limiting the number of threads used with an ExecutorService, cancelling Async Promises when they're no longer needed, and handling exceptions properly to avoid application crashes. Also, be mindful of potential issues related to concurrent access and synchronization when working with multiple threads.

  1. How can I set a timeout on an Async Promise in Java?

You can use the CompletableFuture.supplyAsync() method with a Callable that wraps your asynchronous operation in a try-catch block, setting a timeout using the ManualResetEvent class and the await() method. If the timeout is exceeded, you can throw an exception to be handled by the whenComplete() or handle() methods.

  1. How do I handle exceptions in chained Async Promises effectively?

To handle exceptions in chained Async Promises effectively, you should use the whenComplete() or handle() methods and provide a handler that can handle specific exceptions or rethrow them if necessary. You may also want to consider using multiple exception handlers for different types of exceptions.

  1. What are some common issues related to concurrent access and synchronization when working with Async Promises in Java?

Common issues related to concurrent access and synchronization include race conditions, deadlocks, and livelocks. To avoid these issues, you should use proper locking mechanisms (e.g., synchronized blocks, locks, semaphores) and ensure that your code is thread-safe.

  1. How can I monitor the progress of an Async Promise in Java?

To monitor the progress of an Async Promise in Java, you can use the whenComplete() or handle() methods to print intermediate results or perform other actions at different stages of the asynchronous operation. You may also want to consider using third-party libraries that provide more advanced monitoring and debugging features for CompletableFutures.

  1. What are some performance considerations when working with Async Promises in Java?

Performance considerations when working with Async Promises in Java include the number of threads used, the size of the data being processed, and the potential for blocking operations (e.g., I/O operations). To optimize performance, you should limit the number of threads used, avoid blocking operations whenever possible, and ensure that your code is efficient and well-optimized.

Async Promises (Java) | Java | XQA Learn