update multi-thread, coroutine env docs

Author: Hyeon9mak

README-java-asynchronous-environments-EN.md

@@ -27,7 +27,7 @@ So, the new thread cannot access the original request context.
 
 Spring provides `TaskDecorator` which allows copying the request context to new threads before executing asynchronous tasks.
 
-### 1-1. Configure ThreadPoolTaskExecutor
+### 1. Configure ThreadPoolTaskExecutor
 
 ```java
 import org.springframework.context.annotation.Bean;
@@ -68,7 +68,7 @@ public class AsyncConfig {
 }
 ```
 
-### 1-2. Using CompletableFuture
+### 2. Using CompletableFuture
 
 When using CompletableFuture directly, use the custom Executor:
 
@@ -84,7 +84,7 @@ public CompletableFuture<List<User>> findAllUsersAsync() {
 }
 ```
 
-### 1-3. Using @Async Annotation
+### 3. Using @Async Annotation
 
 When using the @Async annotation, explicitly specify the configured Executor:
 
@@ -101,17 +101,4 @@ public CompletableFuture<User> findUserByIdAsync(Long id) {
 
 ## 🖥️ WebFlux/Reactor Environment
 
-In a WebFlux environment, you can propagate the context as follows:
-
-```java
-@GetMapping("/users/reactive")
-public Flux<User> getAllUsers() {
-    return Flux.deferContextual(contextView -> {
-        // Get information from the current context
-        // Execute async operations
-        return userRepository.findAllReactive();
-    });
-}
-```
-
-You can also automate context propagation using library like `reactor-core-micrometer`.
+(WIP)

README-java-asynchronous-environments.md

@@ -102,17 +102,4 @@ public CompletableFuture<User> findUserByIdAsync(Long id) {
 
 ## 🖥️ WebFlux/Reactor 환경
 
-WebFlux 환경에서는 다음과 같이 컨텍스트를 전파할 수 있습니다:
-
-```java
-@GetMapping("/users/reactive")
-public Flux<User> getAllUsers() {
-    return Flux.deferContextual(contextView -> {
-        // 현재 컨텍스트에서 정보 가져오기
-        // 비동기 작업 실행하기
-        return userRepository.findAllReactive();
-    });
-}
-```
-
-그 외에도 `reactor-core-micrometer` 와 같은 라이브러리를 활용하여 컨텍스트 전파를 자동화 할 수 있습니다.
+(WIP)

README-kotlin-coroutine-environments-EN.md

@@ -0,0 +1,92 @@
+# 🖥️ Kotlin Coroutine Environments QueryCountPerRequest Usage Guide
+
+**English** | [한국어](README-kotlin-coroutine-environments.md)
+
+## 🖥️ Overview
+
+The Multi-Datasource-Query-Counter library counts the number of DB queries per API request.
+The library basically uses `@RequestScope` to ensure that each API request has its own counter.
+However, in Kotlin Coroutine environments, since Coroutines can freely move between threads (`suspension`, `resumption`),
+an issue may occur where the context of `RequestContextHolder` is not maintained.
+
+This guide explains how to properly use `QueryCountPerRequest` in Coroutine environments.
+
+<br>
+
+## 🖥️ The Problem
+
+Coroutines have the following characteristics:
+
+1. **Suspension, Resumption**: Coroutines can be suspended and resumed at any time.
+2. **Thread Switching**: When a Coroutine resumes, it can resume on a different thread than the original one.
+3. **Context Propagation**: When starting a new Coroutine with builders like `async` or `launch`, the parent Coroutine's context may not be automatically propagated.
+
+Therefore, it is difficult to properly use `QueryCountPerRequest` by default.
+
+<br>
+
+## 🖥️ Solution: Coroutine Context Element
+
+### 1. Using CoroutineQueryCountContextElement
+
+`CoroutineQueryCountContextElement` implements the [`ThreadContextElement` interface](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-thread-context-element/) to propagate `RequestAttributes` to the branching Coroutine contexts.
+
+```kotlin
+class CoroutineQueryCountContextElement(
+    private val requestAttributes: RequestAttributes = RequestContextHolder.currentRequestAttributes(),
+) : ThreadContextElement<RequestAttributes> {
+
+    companion object Key : CoroutineContext.Key<CoroutineQueryCountContextElement>
+
+    override val key: CoroutineContext.Key<CoroutineQueryCountContextElement>
+        get() = Key
+
+    override fun updateThreadContext(context: CoroutineContext): RequestAttributes {
+        RequestContextHolder.setRequestAttributes(requestAttributes)
+        return requestAttributes
+    }
+
+    override fun restoreThreadContext(context: CoroutineContext, oldState: RequestAttributes) {
+        RequestContextHolder.setRequestAttributes(oldState)
+    }
+}
+```
+
+The actual implementation is included in the library, so you can use it immediately.
+
+### 2. Usage Example
+
+```kotlin
+@RestController
+class UserController(
+    private val userRepository: UserRepository,
+) {
+    @CountQueries
+    @GetMapping("/users/coroutine")
+    fun getUsers() {
+        // Now this Coroutine and its branching Coroutines maintain the same RequestAttributes
+        val element = CoroutineQueryCountContextElement()
+        val threadPool = ForkJoinPool(2)
+        return runBlocking(threadPool.asCoroutineDispatcher() + element) {
+            val usersDeferred = async {
+                userRepository.findAllUsers() // Query count point.
+            }
+
+            val countDeferred = async {
+                userRepository.count()        // Query count point.
+            }
+            
+            val users = usersDeferred.await()
+            val count = countDeferred.await()
+
+            mapOf("users" to users, "count" to count)
+        }
+    }
+}
+```
+
+<br>
+
+## 🖥️ WebFlux/Reactor Environment
+
+(WIP)