Asynchronous Programming in Java

Last Updated : 9 May 2025

Asynchronous programming in Java allows tasks to execute independently without hindering the main thread, enhancing performance and responsiveness. It is commonly utilized for managing concurrent operations, background tasks, and I/O processing.

Asynchronous Techniques in Java

Callbacks and Callback Hell: Callbacks act as reminders, notifying when a task is complete. However, excessive callbacks can lead to callback hell, making code complex and difficult to manage.
Java’s CompletableFuture: Launched in Java 8, CompletableFuture enhances asynchronous programming by facilitating task chaining, preventing callback hell, and boosting code readability.
ExecutorService for Asynchronous Tasks: ExecutorService oversees a group of worker threads, enabling various tasks to execute concurrently, akin to a team of chefs preparing different dishes at the same time.
Java 8 and Asynchronous Programming: Java 8 improved asynchronous features with CompletableFuture, offering improved management of task execution, linking, and effectively merging several tasks.

Approaches for Asynchronous Programming

Java provides two commonly used approaches for handling asynchronous tasks:

Callbacks with CompletableFuture: Uses CompletableFuture to execute tasks asynchronously while avoiding callback hell through chaining and combining operations.
Asynchronous Programming with Future and ExecutorService: Uses Future and ExecutorService to manage tasks in a thread pool, retrieving results once the tasks are completed.

Callbacks with CompletableFuture

In Java, Callbacks are used to handle the results of asynchronous tasks once they are completed. The traditional approach can sometimes lead to Callback Hell, where nested callbacks make code difficult to manage.

Algorithm

Step 1: Initiate an asynchronous task with CompletableFuture.supplyAsync() to execute a section of code in another thread.

Step 2: Within the asynchronous task, imitate a delay by halting the thread for 200 milliseconds through Thread.sleep().

Step 3: After the delay, return a string message ("Greetings from CompletableFuture!").

Step 4: Use thenAccept() method to handle and print the result once the asynchronous task completes.

Step 5: To allow the asynchronous task to finish before the program ends, pause the main thread for 300 milliseconds using Thread.sleep().

Implementation

import java.util.concurrent.CompletableFuture;  // Import CompletableFuture class
public class CompletableFutureExample {  // Class definition
    public static void main(String[] args) {
        // Asynchronous task using CompletableFuture
        CompletableFuture<String> futureTask = CompletableFuture.supplyAsync(() -> {  // Create CompletableFuture and run asynchronously
            try {
                // Simulating a delay
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();  // Print the exception if occurs
            }
            return "Greetings from CompletableFuture!";  // Return the result of the asynchronous task
        });
        // Handling the result once the task is complete
        futureTask.thenAccept(result -> System.out.println(result));  // Print the result once the task is complete
        // Adding delay to allow asynchronous task to complete
        try {
            Thread.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();  // Print the exception if occurs
        }
    }
}   

Output:

 
Greetings from CompletableFuture!

Asynchronous Programming with Future and ExecutorService

In Java, Asynchronous Programming enables tasks to execute simultaneously without hindering the main thread. By utilizing ExecutorService, you can handle and perform tasks in distinct threads. Upon submitting a task, it yields a Future object, enabling you to obtain the task result once it has finished.

Algorithm

Step 1: Set up an ExecutorService by using Executors.newSingleThreadExecutor() for handling thread execution.

Step 2: Utilize the executorService.submit() method to present an asynchronous task and return a Future object that will contain the task's outcome.

Step 3: Inside the task, simulate a delay by calling Thread.sleep(200).

Step 4: Use taskResult.get() to retrieve the result of the task. This call blocks until the task is completed.

Step 5: After the task finishes and the result is printed, call the executorService.shutdown() method to clean up and stop the executor.

Implementation

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class FutureExample {
    public static void main(String[] args) {
        // Create an ExecutorService to manage thread execution
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        // Submit a task for execution and return a Future object
        Future<String> taskResult = executorService.submit(() -> {
            try {
                // Simulate a delay in the task
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();  // Handle interruption during sleep
            }
            return "Greetings from Future!";
        });
        try {
            // Retrieve the result of the asynchronous task
            String result = taskResult.get();  // This blocks until the task is complete
            System.out.println("Task Result: " + result);
        } catch (Exception e) {
            e.printStackTrace();  // Handle potential exceptions
        }
        // Shutdown the executor after task completion
        executorService.shutdown();
    }
}   

Output:

 
Task Result: Greetings from Future!

Real-world Applications and Use Cases

Web Development and Asynchronous Tasks: In web development with Java, asynchronous programming allows the server to handle multiple requests simultaneously. It is similar to a restaurant serving many customers at once without making each one wait for too long.

Asynchronous I/O Operations: When performing I/O tasks like reading or writing data, asynchronous programming permits the system to handle other activities while waiting for the I/O process to finish. It's akin to reading a book while expecting the washing machine to finish instead of just waiting idly.

Next TopicSierpinski Number in Java

← prev next →

We deliver comprehensive tutorials, interview question-answers, MCQs, study materials on leading programming languages and web technologies like Data Science, MEAN/MERN full stack development, Python, Java, C++, C, HTML, React, Angular, PHP and much more to support your learning and career growth.