Asynchronous Programming in Spring Boot with CompletableFuture

Published 2026-08-03 by Shubham Bhati — Backend Engineer (Java 17, Spring Boot, Microservices).

Supercharge Your Spring Boot Apps: Mastering Asynchronous Operations with CompletableFuture

Hey fellow backend engineers! Shubham Bhati here. Ever stared at your Prometheus dashboard, watching API latency spike into the hundreds of milliseconds because a single request had to hit multiple external services? That blocking I/O waiting game is a killer for user experience and server efficiency. If your Spring Boot application is struggling with sluggish response times due to sequential calls to databases, third-party APIs or message queues, it's time to go async. We're talking about embracing CompletableFuture with spring boot async completablefuture to parallelize tasks and reclaim those precious milliseconds, giving your applications the performance boost they deserve.

Kickstarting Asynchronicity with @Async

The simplest way to introduce java async behavior in Spring Boot is with the @Async annotation. It's incredibly straightforward: mark a method with @Async, and Spring will execute it in a separate thread. First, you need to enable async processing in your main application class or a configuration class using @EnableAsync. Then, any method within a Spring-managed bean annotated with @Async will be executed by a ThreadPoolTaskExecutor managed by Spring. This immediately frees up the calling thread to continue its work, preventing it from blocking.

Consider a scenario where you need to send an email notification after a user action, but the user doesn't need to wait for the email to be fully sent.

// Main Application Class
@SpringBootApplication
@EnableAsync
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

// EmailService.java
@Service
public class EmailService {

    @Async
    public void sendWelcomeEmail(String userEmail) {
        System.out.println("Sending welcome email to: " + userEmail + " in thread: " + Thread.currentThread().getName());
        try {
            Thread.sleep(2000); // Simulate network latency or complex email templating
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("Email sent to: " + userEmail);
    }
}

Production Note: While @Async is easy, relying on Spring's default SimpleAsyncTaskExecutor is often insufficient for production. It creates a new thread for every task, which can quickly lead to thread exhaustion and out-of-memory errors under high load. For any serious spring async annotation usage, you'll want to configure a custom thread pool.

Custom Thread Pools: The Foundation of Control

To prevent unbounded thread creation and manage resources effectively, you must configure a custom ThreadPoolTaskExecutor for your @Async methods. This gives you granular control over thread count, queue capacity, and rejection policies. A well-configured thread pool ensures your application can handle concurrent async tasks without compromising stability or performance. You need to provide a custom Executor bean, and Spring will use it for @Async methods if present.

Here's how to set up a dedicated thread pool for your async tasks:

// AsyncConfig.java
@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean(name = "taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // Number of threads always alive
        executor.setMaxPoolSize(10); // Max number of threads that can be created
        executor.setQueueCapacity(25); // Queue for tasks when all threads are busy
        executor.setThreadNamePrefix("AsyncService-"); // Prefix for thread names
        executor.initialize();
        return executor;
    }
}

// In your service method, specify the executor
@Service
public class NotificationService {

    @Async("taskExecutor") // Use the named executor
    public CompletableFuture<String> sendSmsNotification(String phoneNumber) {
        System.out.println("Sending SMS to: " + phoneNumber + " in thread: " + Thread.currentThread().getName());
        try {
            Thread.sleep(1500); // Simulate external SMS API call
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return CompletableFuture.completedFuture("SMS failed for " + phoneNumber);
        }
        return CompletableFuture.completedFuture("SMS sent to " + phoneNumber);
    }
}

Production Note: Sizing your thread pool is crucial. For CPU-bound tasks, corePoolSize should be close to the number of CPU cores. For I/O-bound tasks (like external API calls), it can be much larger, as threads spend most of their time waiting. Monitor your thread pool metrics (active threads, queue size, completed tasks) to tune it for optimal performance and to avoid latency p99 spikes caused by overloaded queues or thread contention.

CompletableFuture: Unleashing True Asynchronicity

While @Async runs methods in a separate thread, CompletableFuture provides a powerful API for chaining, combining, and handling results of java async operations in a non-blocking way. It's the go-to for situations where you need to perform multiple independent tasks concurrently and then aggregate their results, or when one task depends on the outcome of another. CompletableFuture allows you to write highly concurrent, reactive code that significantly improves perceived performance. It's not just about fire-and-forget; it's about orchestration.

Imagine fetching user details and their order history concurrently, then combining them.

@Service
public class UserService {

    @Async("taskExecutor") // Even with CompletableFuture, @Async uses a custom executor
    public CompletableFuture<User> fetchUserDetails(String userId) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("Fetching user details for " + userId + " in thread: " + Thread.currentThread().getName());
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return new User(userId, "John Doe");
        }, AsyncConfig.taskExecutor()); // Explicitly provide executor if not using @Async
    }

    @Async("taskExecutor")
    public CompletableFuture<List<Order>> fetchUserOrders(String userId) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("Fetching orders for " + userId + " in thread: " + Thread.currentThread().getName());
            try {
                Thread.sleep(150);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return Arrays.asList(new Order("1", 100.0), new Order("2", 250.0));
        }, AsyncConfig.taskExecutor());
    }

    public CompletableFuture<CombinedUserData> getCombinedData(String userId) {
        CompletableFuture<User> userFuture = fetchUserDetails(userId);
        CompletableFuture<List<Order>> ordersFuture = fetchUserOrders(userId);

        return CompletableFuture.allOf(userFuture, ordersFuture)
                .thenApply(v -> {
                    try {
                        User user = userFuture.get();
                        List<Order> orders = ordersFuture.get();
                        return new CombinedUserData(user, orders);
                    } catch (Exception e) {
                        throw new RuntimeException("Failed to combine user data", e);
                    }
                });
    }
}

Production Note: CompletableFuture can reduce latency p99 by running independent operations in parallel. Pay attention to error handling with exceptionally() or handle() to prevent silent failures. Be mindful of memory footprint if you're holding onto many CompletableFuture instances and their results; ensure you're consuming results and releasing references efficiently.

Common Pitfalls

• Not configuring a custom ThreadPoolTaskExecutor: Relying on Spring's default SimpleAsyncTaskExecutor can lead to performance degradation and OutOfMemoryErrors in production environments due to unlimited thread creation.
• Blocking inside @Async methods: If your async method still performs blocking I/O (like a synchronous database call or external API call without an async client), you're still blocking a thread pool thread, defeating the purpose of asynchronicity for that task.
• Ignoring error handling: CompletableFuture tasks can fail silently if you don't use methods like exceptionally() or handle() to explicitly manage exceptions. This makes debugging incredibly difficult.
• Misunderstanding CompletableFuture.get(): Calling .get() on a CompletableFuture blocks the calling thread until the result is available. While necessary sometimes, overuse negates the non-blocking benefits.

Conclusion

Mastering spring boot async completablefuture is a vital skill for building high-performance, responsive backend services. By correctly using @Async with a custom thread pool and orchestrating complex workflows with CompletableFuture, you can significantly reduce API response times, improve resource utilization, and deliver a better user experience. Start refactoring those blocking operations today and unlock the true potential of your Spring Boot applications. Happy coding!

---

Further Reading

• Spring Boot Official Documentation
• Baeldung — Java & Spring Tutorials
• Oracle Java Documentation

---

Written by **Shubham Bhati* — Backend Engineer at AlignBits LLC, specializing in Java 17, Spring Boot, microservices, and AI integration. Connect on LinkedIn, GitHub, or read more at shubh2-0.github.io.*