Kotlin Coroutine equivalent way as @Async in Spring Java

Spring provides a way to support asynchronous execution with annotation of @Async and @EnableAsync, in the below code as Java, my API won't be blocked and can respond without waiting for the expensive operation to be finished.

@Post
public Response saveUserDetail(UserDetail userDetail) {
   System.out.println("saveUserDetail Started...");
   // very expensive operation
   userRepo.save(userDetail);
   System.out.println("saveUserDetail Completed...");
}

@Async
public void save(UserDetail userDetail) {
   // took 30s
   Thread.sleep(30000);
}

Now Kotlin has a coroutine package to write an async process in a sync way, however, what'd be the Kotlin way to achieve the above behaviour without using @Async? I've tried suspend and async but they seem will still block my request thread that I cannot get my API response without waiting in expensive operation

Kotlin coroutines are not the same as regular Java threads. Coroutines have two properties that are different than threads which I believe are relevant to you:

1. Coroutines use structured concurrency. An outer coroutine scope will not complete until all child coroutines are complete.

2. Coroutines should not be blocked by calls such as Thread.sleep() unless care is taken to run such blocking code in a dispatcher designed for it, such as Dispatchers.IO. Instead, use a suspending call like delay() See https://stackoverflow.com/a/76009163/430128 for details about this.

Now in your case, it appears you want saveUserDetail to complete without waiting for save to finish. Keep in mind this Spring code isn't safe, because if saveUserDetail throws an error, the client will never know about it. Or if saveUserDetail never returns for some reason, the thread will leak. Structured concurrency in Kotlin is intended to prevent such unsafe code by default. With coroutines and structured concurrency, the response will not return until the saveUserDetail call finishes, and it doesn't matter if the async or launch coroutine builders are used or not, because by default they simply start a child coroutine. The parent still won't complete until the child coroutine started by async or launch is done.

If you really want the unsafe version of this code, you need to launch the coroutine into a different coroutine scope that is not a child of the request scope, such as the GlobalScope. For example:

GlobalScope.launch {
  userRepo.save(userDetail);
}

Make sure you read all the caveats of using GlobalScope in the docs.

You can also create your own background scope and use that. Example:

val backgroundOpsScope = CoroutineScope(SupervisorJob())
...
suspend fun saveUserDetail(userDetail: UserDetail) {
  backgroundOpsScope.launch {
    ... expensive operation ...
  }
}