How to Use @Async in Spring Boot

Using @Async in a Spring Boot application allows you to manage and execute asynchronous tasks efficiently. This guide will walk you through the steps required to set up and use @Async in your Spring Boot application.

Step 1: Add Dependencies

To use @Async, ensure that you have the necessary dependencies included in your project. Typically, if you are using Spring Boot Starter Web, it already includes the necessary dependencies. However, you can add them explicitly in your pom.xml for Maven or for Gradle.

Maven

dependency
    
    artifactIdspring-boot-starter-aop/artifactId
/dependency

Gradle

implementation ''

Step 2: Create a Configuration Class

In a configuration class, define an utorService bean. This allows Spring to manage the lifecycle of the utorService.

@Configuration
public class utorServiceConfig {
    @Bean
    public utorService taskutor {
        return 10; // Adjust the pool size as needed
    }
}

Step 3: Inject the utorService

You can then inject the utorService into any Spring-managed bean, such as a service, where you want to execute tasks asynchronously.

@Service
public class MyService {
    private final utorService utorService;
    @Autowired
    public MyService(utorService utorService) {
        this.utorService  utorService;
    }
    public FutureString uteTask() {
        return - {
            // Simulate a long-running task
            sleep(2000);
            return Task Complete;
        }
    }
}

Step 4: Use the Service

Now, you can call the method that submits tasks to the utorService. For example, in a controller:

@RestController
public class MyController {
    private final MyService myService;
    @Autowired
    public MyController(MyService myService) {
          myService;
    }
    @GetMapping(/ute)
    public String ute() throws ExecutionException, InterruptedException {
        FutureString future  myService.uteTask();
        return (); // This will block until the task is complete
    }
}

Step 5: Shutdown the utorService

It is good practice to shut down the utorService when your application is stopping. You can achieve this by implementing DisposableBean in your configuration class.

@Configuration
public class utorServiceConfig implements DisposableBean {
    @Bean
    public utorService taskutor {
        return 10;
    }
    @Override
    public void destroy() throws Exception {
        ();
    }
}

Summary

Create a configuration class to define an utorService bean. Inject the utorService in your service class. Submit tasks to the utorService and handle the Future results. Shutdown the utorService when the application context is closed.

This setup allows you to efficiently manage background tasks in your Spring Boot application. Adjust the pool size and task logic based on your specific requirements.

Key Highlights

Spring Boot @Async: Allows you to easily implement asynchronous task execution within your Spring Boot application. @Async in Spring Boot: A useful feature for enhancing performance and responsiveness in your Spring Boot application by executing tasks in the background. Asynchronous tasks in Spring Boot: Implementing @Async can help manage and execute tasks without blocking the main thread, leading to better performance and faster response times.