Async Processing with @Async

As modern applications scale, running long tasks synchronously can slow down APIs and degrade user experience. Tasks like sending emails, generating reports, processing files, or calling third-party APIs should not block the main request thread.

That’s where @Async in Spring Boot becomes powerful. It allows methods to run in a separate thread without manually managing thread creation.

What Is @Async?

@Async is a Spring annotation that allows a method to run in a separate thread, enabling asynchronous processing without blocking the main request thread.

Without @Async (Synchronous Execution)

Client → Controller → Service → Long Task → Response (waits)

• The request thread waits until the task finishes.
• The client receives the response only after the entire process completes.
• Long-running operations can slow down APIs and reduce system performance.

With @Async (Asynchronous Execution)

Client → Controller → Service (@Async)
                         ↳ Background Thread Executes Task Response returned immediately

• The method runs in a background thread.
• The client gets an immediate response.
• The long-running task continues processing independently.

Enable Async Processing

To activate asynchronous support in Spring Boot, add @EnableAsync to your main application class:

@EnableAsync
@SpringBootApplication
public class Application {
}

Without @EnableAsync, Spring will not activate async support.

Basic @Async Example

Here’s a simple example of running a method asynchronously:

@Service
public class EmailService {

    @Async
    public void sendEmail(String to) {
        System.out.println("Sending email...");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
        System.out.println("Email sent to " + to);
    }
}

Calling the method:

emailService.sendEmail("[email protected]");

The sendEmail() method runs in a separate background thread, so the main request thread does not wait for it to finish.

Returning Values from @Async

If you need to return a result from an asynchronous method, use CompletableFuture:

@Async
public CompletableFuture<String> processOrder() {
    return CompletableFuture.completedFuture("Order Processed");
}

Calling the method:

CompletableFuture<String> result = orderService.processOrder();
System.out.println(result.get());

Spring supports the following return types for async methods:

• Future
• CompletableFuture
• ListenableFuture

How @Async Works Internally

Spring executes @Async methods using proxy-based AOP and a TaskExecutor (thread pool) behind the scenes.

• Spring creates a proxy around the bean that contains the @Async method.
• When the method is called, the proxy intercepts the call.
• Instead of executing the method immediately, it submits the task to a thread pool (TaskExecutor).
• The task runs in a separate background thread, allowing the main request thread to return immediately.

Execution Flow

Client → Spring Proxy → Task Submitted to Thread Pool → Executes in Background

Important:

• Spring creates a proxy around the bean.
• The proxy intercepts @Async methods.
• Self-invocation (calling async method inside same class) will NOT work because the proxy is bypassed.
• Only public methods are supported.

Configure Custom Thread Pool (Production Ready)

By default, Spring uses a simple executor, which is not ideal for high-traffic production systems. For better performance and stability, always configure a custom thread pool.

Custom Async Configuration

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);      // Minimum threads always active
        executor.setMaxPoolSize(10);      // Maximum threads allowed
        executor.setQueueCapacity(50);    // Queue size before creating new threads
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

Use specific executor:

@Async("taskExecutor")
public void sendEmail(String to) {
    // async logic here
}

Why configure it?

• Controls the number of threads used by async tasks
• Prevents memory exhaustion caused by unlimited threads
• Avoids performance bottlenecks under heavy load
• Improves system stability and scalability in production

Exception Handling in Async Methods

In Spring Boot, exceptions thrown inside @Async methods behave differently depending on the return type.

• If the async method returns void, exceptions are not automatically propagated to the caller.
• If it returns Future or CompletableFuture, exceptions can be handled using .get() or .exceptionally().

For void async methods, you should implement a custom exception handler.

Implement a custom handler:

Step 1: Create a Custom Async Exception Handler

import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import java.lang.reflect.Method;

public class AsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        System.out.println("Async error in method: " + method.getName());
        System.out.println("Error message: " + ex.getMessage());
    }
}

This handler captures uncaught exceptions from async methods and allows you to log or monitor them properly.

Step 2: Register the Exception Handler

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.Executor;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        return new ThreadPoolTaskExecutor();
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new AsyncExceptionHandler();
    }
}

• Prevents silent failures in background tasks
• Helps in logging and monitoring async errors
• Improves reliability in production systems
• Essential for email sending, notifications, payment processing, and other background jobs

Real-World Use Cases

In modern Spring Boot applications, @Async is commonly used to handle background tasks that should not block the main request thread.

@Async is ideal for:

• Sending emails or SMS notifications
• Push notification systems
• File uploads and background processing
• Generating reports (PDF, Excel, CSV)
• Audit logging and activity tracking
• Calling external APIs (third-party services)
• Lightweight payment processing steps

Practical Example

When a user registers:

User → Registration API → Response returned immediately
                          ↳ Welcome email sent asynchronously

The API responds instantly to the user, while the email is processed in the background.

Common Mistakes to Avoid

• Forgetting @EnableAsync
• Self-invocation inside same class
• Not configuring a thread pool
• Blocking heavy operations inside async method
• Ignoring exception handling
• Using async for CPU-heavy batch jobs without tuning

@Async vs Messaging Systems

Best Practices for Production

• Define a custom thread pool
• Keep async tasks small and non-blocking
• Monitor thread pool metrics
• Use structured logging and tracing
• Avoid long database transactions
• Switch to message queues for high-scale distributed workflows

Conclusion

@Async in the Spring Framework is a clean and powerful way to improve API responsiveness by offloading long-running tasks to background threads.

When used correctly with:

• Controlled and properly sized thread pools
• Structured exception handling
• Continuous monitoring and performance tuning

It becomes a production-ready solution for handling lightweight asynchronous operations efficiently.