Synchronous to Asynchronous

Converting a synchronous method to an asynchronous one in Java involves modifying the code to allow other tasks to execute while it is waiting for input/output operations to complete. Here’s an example of how to convert a synchronous method to an asynchronous one in Java:

Let’s say we have a synchronous method that performs a CPU-intensive operation:

public int calculate(int x, int y) {
    int result = 0;
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < y; j++) {
            result += i * j;
        }
    }
    return result;
}

To convert this to an asynchronous method, we can make use of the CompletableFuture class in Java. First, we need to change the return type from int to CompletableFuture<Integer>. We also need to mark the method with the Async annotation:

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class CalculationService {

    private ExecutorService executor = Executors.newFixedThreadPool(10);

    @Async
    public CompletableFuture<Integer> calculateAsync(int x, int y) {
        CompletableFuture<Integer> completableFuture = new CompletableFuture<>();
        executor.submit(() -> {
            int result = 0;
            for (int i = 0; i < x; i++) {
                for (int j = 0; j < y; j++) {
                    result += i * j;
                }
            }
            completableFuture.complete(result);
        });
        return completableFuture;
    }
}

In this example, we have used the @Async annotation provided by Spring Framework to mark the method as asynchronous. We have also created a CompletableFuture object to hold the result of the calculation. The calculation is performed inside a separate thread using an ExecutorService, and the result is set in the CompletableFuture object when it becomes available.

By returning a CompletableFuture object, other tasks can continue executing while the calculation is being performed in the background. The caller can then use the get() method on the CompletableFuture object to wait for the result of the calculation.