Asynchronous Processing in Spring Boot with @Async and Executor

In modern backend systems, asynchronous processing is essential for improving performance, scalability, and responsiveness. Whether you’re sending emails, processing files, or making external API calls, offloading tasks from the main thread helps your app stay fast and efficient.

In this post, you’ll learn how to implement asynchronous processing in Spring Boot using @Async and a custom Executor, all using best practices in 2025.

🧠 Why Use Asynchronous Processing?

Asynchronous methods allow tasks to run in parallel with the main thread, which is useful for:

• Sending emails after user registration
• Processing uploaded files
• Making slow HTTP requests
• Running background cleanup or data sync jobs
• Offloading resource-heavy tasks

Instead of blocking the main request, these tasks run independently in the background.

⚙️ Step 1: Add Required Dependencies

If you’re using Spring Boot 3.x, the support for @Async is built in via spring-boot-starter.

Maven:

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
</dependency>

No additional dependency is needed for @Async.

🔧 Step 2: Enable Asynchronous Support

Add @EnableAsync to your main application class or a configuration class:

@SpringBootApplication
@EnableAsync
public class AsyncApp {
    public static void main(String[] args) {
        SpringApplication.run(AsyncApp.class, args);
    }
}

🛠️ Step 3: Create an Async Service

@Service
public class EmailService {

    @Async
    public void sendWelcomeEmail(String email) {
        try {
            Thread.sleep(3000); // Simulate delay
            System.out.println("✅ Sent welcome email to " + email);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

This method runs asynchronously when called — it won’t block the main thread.

🎯 Step 4: Trigger the Async Method

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private EmailService emailService;

    @PostMapping
    public ResponseEntity<String> registerUser(@RequestParam String email) {
        emailService.sendWelcomeEmail(email); // Runs in a separate thread
        return ResponseEntity.ok("User registered, email will be sent soon.");
    }
}

You’ll see the response immediately, while the email method runs in the background.

⚙️ Step 5: Customize the Executor (Optional but Recommended)

Define your own thread pool settings for better control and performance tuning:

@Configuration
public class AsyncConfig {

    @Bean(name = "taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(4);
        executor.setMaxPoolSize(8);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("AsyncThread-");
        executor.initialize();
        return executor;
    }
}

Spring will automatically use this executor for all @Async methods — unless specified otherwise.

🧪 Monitor Thread Execution (for Debugging)

Use logs or Thread.currentThread().getName() to confirm that your async methods are running on a separate thread:

System.out.println("Running async on: " + Thread.currentThread().getName());

⚠️ Caveats and Best Practices

• @Async only works on public methods
• Avoid calling async methods within the same class
• Use CompletableFuture if you want to return results from async methods
• Catch and log exceptions properly — async errors won’t crash your app but may go unnoticed
• Always tune the thread pool for your application’s load pattern

📘 Related:

• How to Handle Exceptions Globally in Spring Boot

🧠 Final Thoughts

Adding asynchronous processing to your Spring Boot app using @Async is one of the simplest ways to improve scalability and responsiveness. Whether you’re building background jobs, event-driven workflows, or simply optimizing request latency — it just takes a few lines of code.

For advanced use cases, consider combining @Async with:

• ✅ Spring Events
• ✅ Kafka or RabbitMQ
• ✅ Scheduled tasks (@Scheduled)
• ✅ Reactive programming (WebFlux)