1. Introduction

In modern software development, performing long-running tasks in the background is a common requirement. Spring Boot simplifies the creation of asynchronous services with the @Async annotation, enabling method execution in a separate thread.

Key Points:

1. @Async causes the annotated method to be run in a separate thread.

2. It can be applied to any public method of a Spring bean.

3. To use @Async, enable asynchronous processing with @EnableAsync in your configuration.

2. Implementation Steps

1. Annotate a Spring Boot main class or a configuration class with @EnableAsync to activate asynchronous processing.

2. Create a service class with a method annotated with @Async.

3. Call the asynchronous method from a controller or another Spring component.

4. Run the application and observe the behavior of the asynchronous method.

3. Implementation Example

Here is the complete code that demonstrates the usage of @Async annotation:

// Step 1: Enable async processing
@SpringBootApplication
@EnableAsync
public class AsyncApplication {

    public static void main(String[] args) {
        SpringApplication.run(AsyncApplication.class, args);
    }
}

// Step 2: Create an async service class
@Service
public class AsyncService {

    @Async
    public CompletableFuture<String> asyncMethod() {
        // Simulate a long-running operation
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("Async operation completed");
    }
}

// Step 3: Create a REST controller to call the async method
@RestController
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @GetMapping("/runAsync")
    public String runAsyncMethod() {
        asyncService.asyncMethod();
        return "Async method called. Check logs for the result.";
    }
}

// Step 4: Run the application and call the /runAsync endpoint

Output:

Async method called. Check logs for the result.

Explanation:

1. @EnableAsync in the AsyncApplication class activates asynchronous processing.

2. The AsyncService class has an asyncMethod annotated with @Async, signaling that it should run asynchronously.

3. When asyncMethod is called, it runs in a separate thread, allowing the calling thread (e.g., the web server's request handler) to return immediately.

4. The AsyncController class provides a REST endpoint to trigger the asynchronous service method.

5. Upon calling the /runAsync endpoint, the server immediately responds with a message, while the asyncMethod continues processing in the background.

6. After a delay of 5 seconds to simulate a long-running task, the asyncMethod completes, and the result would be visible in the logs (not shown here) due to the CompletableFuture returned by the method.