DEV Community

Anh Trần Tuấn
Anh Trần Tuấn

Posted on • Originally published at tuanh.net on

Handling Multithreading in Java with Completable Future

1. Understanding Completable Future

CompletableFuture is part of the java.util.concurrent package and offers a way to write asynchronous, non-blocking code in a more readable and maintainable manner. It represents a future result of an asynchronous computation.

1.1 Creating a Simple CompletableFuture

To start with CompletableFuture , you can create a simple asynchronous task. Here’s an example:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running asynchronously...");
            // Simulate a long-running task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        future.join(); // Wait for the task to complete
        System.out.println("Task completed.");
    }
}
Enter fullscreen mode Exit fullscreen mode
  • CompletableFuture.runAsync() executes a task asynchronously.
  • future.join() blocks the main thread until the task is finished.

Demo Result:

Running asynchronously...
Task completed.
Enter fullscreen mode Exit fullscreen mode

1.2 Using CompletableFuture with Results

You can also use CompletableFuture to return results from asynchronous tasks:

import java.util.concurrent.CompletableFuture;

public class CompletableFutureWithResult {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // Simulate a computation
            return 5 * 5;
        });

        future.thenAccept(result -> {
            System.out.println("The result is: " + result);
        }).join();
    }
}
Enter fullscreen mode Exit fullscreen mode
  • CompletableFuture.supplyAsync() is used for tasks that return a result.
  • thenAccept() processes the result once the computation is complete.

Demo Result:

The result is: 25
Enter fullscreen mode Exit fullscreen mode

2. Combining Multiple CompletableFutures

Handling multiple asynchronous tasks is a common use case. CompletableFuture provides several methods to combine futures.

2.1 Combining Futures with thenCombine

You can combine results from multiple CompletableFutures :

import java.util.concurrent.CompletableFuture;

public class CombiningFutures {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 10);

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

        combinedFuture.thenAccept(result -> {
            System.out.println("Combined result: " + result);
        }).join();
    }
}
Enter fullscreen mode Exit fullscreen mode
  • thenCombine () combines the results of two futures.
  • The combined result is processed using thenAccept ().

Demo Result:

Combined result: 15
Enter fullscreen mode Exit fullscreen mode

2.2 Handling Multiple Futures with allOf

When you need to wait for multiple futures to complete, use CompletableFuture.allOf():

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            // Simulate task
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            // Simulate another task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);

        allOfFuture.join();
        System.out.println("All tasks completed.");
    }
}
Enter fullscreen mode Exit fullscreen mode
  • CompletableFuture.allOf() waits for all given futures to complete.
  • join() ensures the main thread waits until all tasks are done.

Demo Result:

All tasks completed.
Enter fullscreen mode Exit fullscreen mode

3. Error Handling with CompletableFuture

Handling errors is essential in asynchronous programming. CompletableFuture provides methods to manage exceptions.

3.1 Handling Exceptions with exceptionally

Use exceptionally () to handle exceptions in asynchronous tasks:

import java.util.concurrent.CompletableFuture;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong!");
        }).exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return null;
        });

        future.join();
    }
}
Enter fullscreen mode Exit fullscreen mode
  • exceptionally () catches and handles exceptions.
  • It allows you to provide a fallback result or handle the error.

Demo Result:

Exception occurred: Something went wrong!
Enter fullscreen mode Exit fullscreen mode

4. Advantages and Disadvantages of CompletableFuture

4.1 Advantages

  • Asynchronous Execution : Efficiently handles tasks that run concurrently without blocking the main thread.
  • Improved Readability : Provides a more readable and maintainable way to handle asynchronous code compared to traditional callback approaches.
  • Rich API : Offers a variety of methods to combine, handle, and compose multiple futures.

4.2 Disadvantages

  • Complexity : While powerful, CompletableFuture can introduce complexity in managing and debugging asynchronous code.
  • Exception Handling: Handling exceptions can sometimes be tricky, especially in complex scenarios with multiple stages.

5. Conclusion

In this guide, we've explored how CompletableFuture can be used to handle concurrent requests in Java. From creating simple asynchronous tasks to combining multiple futures and handling errors, CompletableFuture provides a robust and flexible approach to asynchronous programming.

If you have any questions or need further assistance, feel free to leave a comment below. I’d be happy to help!

Read posts more at : Handling Multithreading in Java with Completable Future

Top comments (0)