인프런 커뮤니티 질문&답변

상세한 답변 너무 감사드립니다. 그래서 저도 코틀린을 조금 더 효과적으로 사용해 보기 위해 스프링 MVC에 webClient를 적용해 보는 방안을 테스트 해보고 있는데요,

suspend fun getUser(id: String):UserResponse {
    return webClient.get()
            .uri("/users/$id")
            .retrieve()
            .awaitBody<UserResponse>()
}

예를들어 위와 같은 webClient 기반의 method가 있다고 할때 suspend가 붙었으니 이를 호출하는 서비스 레이어도 마찬가지고 suspend가 붙어야 할꺼 같고,

그럼 말씀 주신것 처럼 Controller Level 까지 suspend를 붙여 사용하는게 가능하겠지만 개인적으론 결국 스레드가 요청에 고정된 방식에서 suspend 키워드를 통해 요청이 중단되었을때 다른 요청을 해당 스레드가 사용하여 스레드의 효율을 올리는 처리는 안될것 같고

(suspend 함수만 만들었을 경우 내부에선 결국 하나의 코루틴이라 동기처리와 다르지 않고, 서블릿 엔진? 입장에서도 요청에 스레드가 고정이라 별다른 의미가 없는)

그렇다고 서비스 레이어에서 getUser()를 호출할때 해당 작업 자체는 awaitBody()에 의해 결과를 기다리고 있기에 비동기(결과를 기다리지 않고 다른 작업을 수행) 처리도 딱히 아닌것 같은 생각이 있습니다.

때문에, getUser() 요청의 결과를 기다리지 않고 다른 작업(blocking 기반의 DB 작업?)을 하려면 async { getUser() } 로 감싸고 실제 결과가 필요한 부분에 job.await()를 해야 하나 싶은데요,

테스트해본 패턴을 정리 해보자면,

fun getUser(id: String):UserResponse {
    return runBlocking {
        webClient.get()
            .uri("/users/$id")
            .retrieve()
            .awaitBody<UserResponse>()
    }
}

과 같이 webClient 처리지만 호출부에서 결과를 바로 사용해야 해서 딱히 비동기처리가 필요 없을 경우 내부에 runBlocking를 붙여 호출부에서 조금 편하게 사용하는 방법이 있을거 같고

suspend fun getUser(id: String):UserResponse {
    return webClient.get()
            .uri("/users/$id")
            .retrieve()
            .awaitBody<UserResponse>()
}

으로 suspend 함수를 호출하려면 호출부에서 async { } 를 사용해 단일 스레드로 병렬처리가 가능한 효과를 내는 방법이 필요하지 않나? 생각해 보았습니다.

혹시 이런 방식이 실무에서 Spring MVC + WebClient 기반으로 사용하는 방식이 맞을까요??

일반적으로 사용하는 다른 방식이 있을지 궁금합니다.

추가로 아래와 같이 runBlocking 으로 처리된 메소드를 두번 호출을 해도 async {}로 감싸면 비동기로 동시 처리가 되던데 동작 방식이 잘 이해가 가지 않습니다ㅜ

@GetMapping("/test")
fun test(): String = runBlocking {
    val user1 = async { getUser() }
    val user2 = async { getUser() }

    user1.await()
    user2.await()
    "OK"
}

fun getUser(id: String):UserResponse {
    return runBlocking {
        webClient.get()
            .uri("/users/$id")
            .retrieve()
            .awaitBody<UserResponse>()
    }
}

살짝만 설명 부탁드려도 괜찮을까요??

네 그럼요~ 🙂 결론부터 말씀드리면 runBlocking + async + WebClient를 이용한 nonbocking I/O가 가장 일반적인 패턴인데요~

이 경우 스프링 MVC에서 한 스레드가 한 요청에 고정되어 지는 것은 맞지만, RestTemplate을 2회 연속 호출하면 Network I/O 를 탈 때마다 해당 스레드가 blocking 되어 각각 3초 씩 총 6초가 걸린다고 하면,

코루틴과 WebClient를 함께 사용하게 되면 한 스레드에서 병렬로 처리가 되기 때문에 총 3.1초 정도만 걸립니다.

예를 들어 보겠습니다.

@GetMapping("/test")
fun test(): String = runBlocking {
    val user1 = async { getUser(1L) }
    val user2 = async { getUser(2L) }

    return user1.await() + user2.await()
}

suspend fun getUser(id: String): UserResponse {
    return webClient.get() // runBlocking이 없습니다!
            .uri("/users/$id")
            .retrieve()
            .awaitBody<UserResponse>()
}

대략 이런 코드가 있다고 합시다. 이때 getUser() 에서는 webClient + awaitBody() 를 사용하고 있는데요,

Spring MVC는 1 Thread / 1 Request 구조를 갖고 있기 때문에, 하나의 요청이 들어오면 하나의 스레드가 해당 요청을 처리하게 됩니다. 그리고 우리는 runBlocking() 을 사용했기 때문에 우리가 작성한 함수 Body

val user1 = async { getUser(1L) }
val user2 = async { getUser(2L) }

return user1.await() + user2.await()

가 완전히 종료될 때까지 할당 받은 1개의 스레드가 멈추게 되죠.

이는 어차피 runBlocking을 사용할 때나 사용하지 않을 때나 동일한 동작입니다. MVC에서는 Controller에 작성한 로직이 모두 호출될 때까지 요청을 처리하는 스레드가 스레드풀에 반납되지 않는 것이 일반적이죠.

그리고 내부 동작은 이렇게 됩니다.

1. 요청이 들어오면 MVC는 스레드를 할당, Hander를 정하고 해당 Controller의 함수가 실행된다.

2. runBlocking을 타고 들어가 첫 번째 API 호출 지점을 만난다.

3. 우리가 작성한 getUser(1L)을 실행하게 되는데, 비동기 처리가 되어 있기 때문에 getUser(2L) 도 연이어 호출한다.

4. 그리고 user1.await() 과 user2.await()에 걸려 거의 동시에 호출한 API의 응답을 기다린후

5. 대략 3초 정도 지나면 최종 결과를 연산해 반환한다.

보시면 스레드를 2개 사용해 API를 동시에 2개 호출한게 아니라, 1개의 스레드 내에서 API를 2번 동시에 호출하는 것처럼 동작하게 됩니다. 그리고 코드를 읽을 때 역시 suspend 라거나 async 라거나 코루틴과 관련된 코드는 일부 있어도 동기 코드 처럼 함수 호출과 연산이라는 직관적인 코드로 구성되죠 🙂

여기서 만약 Blocking I/O를 사용할 수 밖에 없다고 한다면,

val r1 = async(Dispatchers.IO) { tempClient.call() }

처럼 async 옆에 Dispatcher만 적절히 지정해 주어 여러 blocking I/O를 쉽게 멀티 스레드로 돌릴 수도 있게 됩니다.

몇 가지 테스트와 추론을 통해 Best Pracitces을 빠르게 찾으시네요~ 👍 감사합니다. 🙇