Kotlin coroutines 톺아보기

Kotlin Coroutines 톺아보기
발 표 자 : 김태우(당근마켓 로컬 커머스 팀)
밋업자료 :
밋업코드 : https://github.com/gaaon/kotlin-coroutines-examples

00 비동기에 대한 고민
01 Coroutine 소개
02 Coroutine 톺아보기
03 다음회 예고
목차
목차

- 로컬 커머스팀 백엔드 개발자
- 커머스에서 로컬의 가치를 찾는 팀
시작하기에 앞서

- 한번에 이해하기 힘들다
- 추적이 어렵다
- 에러 핸들링이 어렵다
00. 비동기에 대한 고민
userRepository.findUserByIdAsMaybe(userId)
.subscribe { buyer ->
addressRepository.findAddressByUserAsPublisher(buyer)
.subscribe(LastItemSubscriber { address ->
checkValidRegion(address)
productRepository.findAllProductsByIdsAsFlux(productIds)
.collectList()
.subscribe { products ->
check(products.isNotEmpty())
storeRepository.findStoresByProductsAsMulti(products)
.collect().asList()
.subscribe().with { stores ->
check(stores.isNotEmpty())
orderRepository.createOrderAsFuture(
buyer, products, stores, address
).whenComplete { order, _ ->
emitter.success(order)
}
}
}
})
}
동기 프로그래밍과 다르다

- 어떻게 혼용해서 써야 할까?
- 어떤 결과 타입을 반환해야 할까?
- 또 다른 비동기 라이브러리가
추가되면?
다양한 비동기 라이브러리

- 우수한 가독성
- 에러 핸들링
- 동시성 처리
- Flow
- Channel
Coroutine이 해결사? suspend fun execute(inputValues: InputValues): Order {
val (userId, productIds) = inputValues
// 1. 구매자 조회
val buyer = userRepository.findUserByIdAsMaybe(userId).awaitSingle()
// 2. 주소 조회 및 유효성 체크
val address = addressRepository.findAddressByUserAsPublisher(buyer).awaitLast()
// 3. 상품들 조회
val products = productRepository.findAllProductsByIdsAsFlux(productIds).asFlow().toList()
// 4. 스토어 조회
val stores = storeRepository.findStoresByProductsAsMulti(products).asFlow().toList()
// 5. 주문 생성
val order = orderRepository.createOrderAsFuture(buyer, products, stores, address).await()
return order
}

- 구매자 정보
- 상품 정보
- 스토어 정보
- 배송지
01. Coroutine 소개
상품 주문

- 구매자 조회
- 주소 조회 및 유효성 체크
- 상품 목록 조회
- 스토어 목록 조회
- 주문 생성
주문 생성 동기 코드 fun execute(inputValues: InputValues): Order {
val buyer = userRepository.findUserByIdSync(userId)
val address = addressRepository.findAddressByUserSync(buyer).last()
val products = productRepository.findAllProductsByIdsSync(productIds)
val stores = storeRepository.findStoresByProductsSync(products)
// 5. 주문 생성
val order =
orderRepository.createOrderSync(buyer, products, stores, address)
return order
}

- rxjava3의 Maybe
- 0 .. 1, Error
구매자 조회 import io.reactivex.rxjava3.core.Maybe
interface UserAsyncRepository {
fun findUserByIdAsMaybe(userId: String): Maybe<User>
}
class UserRxRepository : UserRepositoryBase(), UserAsyncRepository {
override fun findUserByIdAsMaybe(userId: String): Maybe<User> {
val user = prepareUser(userId)
return Maybe.just(user)
.delay(TIME_DELAY_MS, TimeUnit.MILLISECONDS)
}
}

- jdk9의 Flow 사용
- item을 publish 하고 complete
이벤트로 flow 종료
주소 조회 import java.util.concurrent.Flow
interface AddressAsyncRepository {
fun findAddressByUserAsPublisher(user: User): Flow.Publisher<Address>
}

- reactor의 Flux 사용
- 0 .. n, Error
상품 조회 import reactor.core.publisher.Flux
interface ProductAsyncRepository {
fun findAllProductsByIdsAsFlux(productIds: List<String>): Flux<Product>
}

- mutiny의 Multi 사용
- 0 .. n, Error
스토어 조회 import io.smallrye.mutiny.Multi
interface StoreAsyncRepository {
fun findStoresByProductsAsMulti(products: List<Product>): Multi<Store>
}

- jdk8의 CompletableFuture
- complete 되는 시점에 결과 반환
주문 생성 import java.util.concurrent.CompletableFuture
interface OrderAsyncRepository {
fun createOrderAsFuture(
buyer: User,
products: List<Product>,
stores: List<Store>,
address: Address,
): CompletableFuture<Order>
}

- subscribe는 결과를 얻은 시점에
주어진 subscriber (consumer)를
실행하는 일종의 callback
- 반환값들이 아래에서 계속 필요해서
subscribe가 중첩
subscribe hell fun execute(inputValues: InputValues): Mono<Order> {
return Mono.create { emitter ->
.subscribe { buyer ->
.collectList()
storeRepository.findStoresByProductsAsMulti(products)
.collect().asList()
emitter.success(order)
}
}
}
})
}
}
}

- 각각의 비동기 함수를 Reactor로
변경
- RxJava3Adapter
- JdkFlowAdapter
- Flux.collectList
- Flux.from
- Mono.fromFuture
flatMap hell fun execute(inputValues: InputValues): Mono<Order> {
return RxJava3Adapter.maybeToMono(userRepository.findUserByIdAsMaybe(userId))
.flatMap { buyer ->
JdkFlowAdapter.flowPublisherToFlux(
addressRepository.findAddressByUserAsPublisher(buyer))
.last()
.flatMap { address ->
.collectList()
.flatMap { products ->
Flux.from(storeRepository.findStoresByProductsAsMulti(products)
.collectList()
.flatMap { stores ->
Mono.fromFuture(
)
)
}
}
}
}
}

- Maybe<T>.awaitSingle
- Publisher<T>.awaitLast
- Flow<T>.toList
- CompletableFuture<T>.await
Coroutine suspend fun execute(inputValues: InputValues): Order {
// 5. 주문 생성
return order
}

suspend fun execute(inputValues: InputValues): Order {
// 5. 주문 생성
return order
}
fun execute(inputValues: InputValues): Order {
val buyer = userRepository.findUserByIdSync(userId)
val address = addressRepository.findAddressByUserSync(buyer).last()
val products = productRepository.findAllProductsByIdsSync(productIds)
val stores = storeRepository.findStoresByProductsSync(products)
// 5. 주문 생성
val order = orderRepository.createOrderSync(buyer, products, stores, address)
return order
}
동기코드 그리고 Coroutine

Coroutine 실행 @Test
fun `should return a createdOrder in coroutine`() = runBlocking {
// given
val userId = "user1"
val productIds = listOf("product1", "product2", "product3")
// when
val watch = StopWatch().also { it.start() }
val inputValues = CreateOrderCoroutineUseCase.InputValues(userId, productIds)
val createdOrder = createOrderUseCase.execute(inputValues)
watch.stop()
println("Time Elapsed: ${watch.time}ms")
// then
println(createdOrder)
}
- runBlocking은 동기코드에서
coroutine을 실행할 수 있게
bridge 역할

이 앞에는
코드가 많습니다
주의

- 경량화된 쓰레드?
- 특정 지점에서 정지했다가 재개할 수
있는 쓰레드?
02. Coroutine 톺아보기
Coroutine? suspend fun execute(inputValues: InputValues): Order {
// 5. 주문 생성
return order
}

- Finite State Machine 기반의
재귀 함수로 변환
kotlin 컴파일러가 suspend가 붙은 함수에
추가적인 코드를 추가
- Continuation 인자를 타겟 함수에
추가하고 Continuation 구현체를
생성
- 타겟 함수 내의 모든 suspend 함수에
생성한 continuation 객체를 패스
- 코드를 분리해서 switch case 안에
넣고 label을 이용해서 state를 변경
Kotlin Compiler

- execute 함수가 실행되면 재귀
호출을 이용해서 스스로(execute
함수)를 실행하면서 state를 변경
- state가 최종에 도달하면 값을
caller에 반환
FSM 기반의 재귀 함수
재귀호출 재귀호출
재귀호출
재귀호출 complete

FSM 기반의 동기 코드로

- SharedData를 통해서 여러 가지
context를 저장
- label은 state machine의 현재 state
값
- 이전 state에서 찾은 값들을 buyer,
address, products, stores, order에
저장
- resumeWith로 재귀 호출을 하고
결과를 result에 저장
- 인자의 sharedData가 null이라면
생성하고 아니면 있는 sharedData를
사용
FSM 기반의 동기 코드 class SharedData {
var label: Int = 0
lateinit var result: Any
lateinit var buyer: User
lateinit var address: Address
lateinit var products: List<Product>
lateinit var stores: List<Store>
lateinit var order: Order
lateinit var resumeWith: (result: Any) -> Order
}
fun execute(
inputValues: InputValues,
sharedData: SharedData? = null,
): Order {
val that = this
val shared = sharedData ?: SharedData().apply {
this.resumeWith = fun (result: Any): Order {
this.result = result
return that.execute(inputValues, this)
}
}

FSM 기반의 동기 코드
return when (shared.label) {
0 -> {
shared.label = 1
userRepository.findUserByIdSync(userId)
.let { user ->
shared.resumeWith(user)
}
}
1 -> {
shared.label = 2
shared.buyer = shared.result as User
addressRepository.findAddressByUserSync(shared.buyer).last()
.let { address ->
shared.resumeWith(address)
}
}
2 -> {
shared.label = 3
shared.address = shared.result as Address
checkValidRegion(shared.address)
productRepository.findAllProductsByIdsSync(productIds)
.let { products ->
shared.resumeWith(products)
}
}
3 -> {
shared.label = 4
shared.products = shared.result as List<Product>
check(shared.products.isNotEmpty())
storeRepository.findStoresByProductsSync(shared.products)
.let { stores ->
shared.resumeWith(stores)
}
}
4 -> {
shared.label = 5
shared.stores = shared.result as List<Store>
check(shared.stores.isNotEmpty())
orderRepository.createOrderSync(
shared.buyer, shared.products, shared.stores, shared.address
).let { order ->
shared.resumeWith(order)
}
}
5 -> {
shared.order = shared.result as Order
shared.order
}
else -> throw IllegalAccessException()
}

FSM 기반의 동기 코드 ; state 0
0 -> {
shared.label = 1
.let { user ->
}
}
1 -> {
shared.label = 2
.let { address ->
}
}
2 -> {
shared.label = 3
.let { products ->
}
}
3 -> {
shared.label = 4
.let { stores ->
}
}
4 -> {
shared.label = 5
).let { order ->
}
}
5 -> {
shared.order
}
}
}

0 -> {
shared.label = 1
.let { user ->
}
}
1 -> {
shared.label = 2
.let { address ->
}
}
2 -> {
shared.label = 3
.let { products ->
}
}
3 -> {
shared.label = 4
.let { stores ->
}
}
4 -> {
shared.label = 5
).let { order ->
}
}
5 -> {
shared.order
}
}
}

FSM 기반의 동기 코드 ; 실행 @Test
fun `should return a createdOrder in sync with state machine`() {
// given
// when
val inputValues = CreateOrderSyncStateMachineUseCase.InputValues(
userId, productIds)
watch.stop()
// then
}
- execute를 실행할때, 두번째
인자를 넘기지 않아서 default
value인 null로 제공

FSM 기반의 비동기 코드로

- SharedDataContinuation를 통해서
여러 가지 context를 저장
- label은 state machine의 현재 state
값
- 이전 state에서 찾은 값들을 buyer,
address, products, stores, order에
저장
- resumeWith로 재귀 호출을 하여
결과를 result에 저장
- 인자의 sharedData가
SharedDataContinuation 타입이
아니라면 생성
FSM 기반의 비동기 코드 class SharedDataContinuation( // 실제로 continuation 구현체는 method
안에
val completion: Continuation<Any>,
) : Continuation<Any> {
var label: Int = 0
lateinit var resume: () -> Unit
override val context: CoroutineContext = completion.context
override fun resumeWith(result: Result<Any>) {
this.resume()
}
}
fun execute(inputValues: InputValues, completion: Continuation<Any>) {
val that = this
val cont = completion as? SharedDataContinuation
?: SharedDataContinuation(completion).apply {
resume = fun() {
// recursive self
that.execute(inputValues, this)

FSM 기반의 비동기 코드 class SharedDataContinuation(
var label: Int = 0
this.resume()
}
}
val that = this
resume = fun() {
// recursive self
}
public interface Continuation<in T> {
/**
* The context of the coroutine that corresponds to this
continuation.
*/
public val context: CoroutineContext
/**
* Resumes the execution of the corresponding coroutine
passing a successful or failed [result] as the
* return value of the last suspension point.
*/
public fun resumeWith(result: Result<T>)
}

FSM 기반의 비동기 코드 ; 실행
- testContinuation을 생성해서
execute 함수에 주입
@Test
fun `should return a createdOrder in async with state machine`() {
// given
// when
val lock = CountDownLatch(1)
val testContinuation = object : Continuation<Any> {
override val context = EmptyCoroutineContext
watch.stop()
lock.countDown()
println(result.getOrThrow())
}
}
val inputValues = CreateOrderAsyncStateMachine3UseCase.InputValues(userId, productIds)
createOrderUseCase.execute(inputValues, testContinuation)
// then
lock.await(3000, TimeUnit.MILLISECONDS)
}

FSM 기반의 비동기 코드
when (cont.label) {
0 -> {
cont.label = 1
.subscribe { user ->
cont.resumeWith(Result.success(user))
}
}
1 -> {
cont.label = 2
cont.buyer = (cont.result as Result<User>).getOrThrow()
addressRepository.findAddressByUserAsPublisher(cont.buyer)
cont.resumeWith(Result.success(address))
})
}
2 -> {
cont.label = 3
cont.address = (cont.result as Result<Address>).getOrThrow()
checkValidRegion(cont.address)
.collectList()
cont.resumeWith(Result.success(products))
}
}
3 -> {
cont.label = 4
cont.products = (cont.result as Result<List<Product>>).getOrThrow()
check(cont.products.isNotEmpty())
storeRepository.findStoresByProductsAsMulti(cont.products)
.collect().asList()
cont.resumeWith(Result.success(stores))
}
}
4 -> {
cont.label = 5
cont.stores = (cont.result as Result<List<Store>>).getOrThrow()
check(cont.stores.isNotEmpty())
cont.buyer, cont.products, cont.stores, cont.address
cont.resumeWith(Result.success(order))
}
}
5 -> {
cont.order = (cont.result as Result<Order>).getOrThrow()
cont.completion.resumeWith(Result.success(cont.order))
}

FSM 기반의 비동기 코드 ; state 0
when (cont.label) {
0 -> {
cont.label = 1
}
}
1 -> {
cont.label = 2
})
}
2 -> {
cont.label = 3
.collectList()
}
}
}
3 -> {
cont.label = 4
.collect().asList()
}
}
4 -> {
cont.label = 5
}
}
5 -> {
}

when (cont.label) {
0 -> {
cont.label = 1
}
}
1 -> {
cont.label = 2
})
}
2 -> {
cont.label = 3
.collectList()
}
}
}
3 -> {
cont.label = 4
.collect().asList()
}
}
4 -> {
cont.label = 5
}
}
5 -> {
}

FSM 기반의 비동기 코드 ; 최종 class SharedDataContinuation(
var label: Int = 0
this.resume()
}
}
val that = this
resume = fun() {
// recursive self
}
- completion은 외부에서 주입하는
continuation 기반의 객체

FSM 기반의 Coroutines ; 시작
when (cont.label) {
0 -> {
cont.label = 1
}
}
1 -> {
cont.label = 2
})
}
2 -> {
cont.label = 3
.collectList()
}
}
3 -> {
cont.label = 4
.collect().asList()
}
}
4 -> {
cont.label = 5
}
}
5 -> {
}

FSM 기반의 Coroutines ; extension function
fun <T: Any> Maybe<T>.awaitSingle(cont: Continuation<Any>) {
this.subscribe { user ->
}
}
fun <T: Any> Flow.Publisher<T>.awaitLast(cont: Continuation<Any>) {
this.subscribe(LastItemSubscriber { address ->
})
}
fun <T: Any> Flux<T>.toList(cont: Continuation<Any>) {
this.collectList()
}
}
fun <T: Any> Multi<T>.toList(cont: Continuation<Any>) {
this.collect()
.asList()
.subscribeAsCompletionStage()
.whenComplete { stores, _ ->
}
}
fun <T: Any> CompletionStage<T>.awaitSingle(cont:
- 각각의 비동기 라이브러리에서
사용하는 객체에 대한 extension
function 생성
- (Flux.toList, Multi.toList,
CompletionStage.awaitSingle
은 실제와 달라요)

when (cont.label) {
0 -> {
cont.label = 1
}
}
1 -> {
cont.label = 2
})
}
2 -> {
cont.label = 3
.collectList()
}
}
3 -> {
cont.label = 4
.collect().asList()
}
}
4 -> {
cont.label = 5
}
}
5 -> {
}
}

when (cont.label) {
0 -> {
cont.label = 1
userRepository.findUserByIdAsMaybe(userId).awaitSingle(cont)
}
1 -> {
cont.label = 2
.awaitLast(cont)
}
2 -> {
cont.label = 3
.toList(cont)
}
3 -> {
cont.label = 4
.toList(cont)
}
4 -> {
cont.label = 5
).awaitSingle(cont)
}
5 -> {
}
}

FSM 기반의 Coroutines ; when 제거
when (cont.label) {
0 -> {
cont.label = 1
userRepository.findUserByIdAsMaybe(userId).awaitSingle(cont)
}
1 -> {
cont.label = 2
.awaitLast(cont)
}
2 -> {
cont.label = 3
.toList(cont)
}
3 -> {
cont.label = 4
.toList(cont)
}
4 -> {
cont.label = 5
).awaitSingle(cont)
}
5 -> {
}
}

FSM 기반의 Coroutines ; continuation 제거
when (cont.label) {
0 -> {
cont.label = 1
val buyer = userRepository.findUserByIdAsMaybe(userId)
.awaitSingle()
}
1 -> {
cont.label = 2
val address = addressRepository.findAddressByUserAsPublisher(buyer)
.awaitLast()
}
2 -> {
cont.label = 3
val products = productRepository.findAllProductsByIdsAsFlux(productIds)
.toList()
}
3 -> {
cont.label = 4
val stores = storeRepository.findStoresByProductsAsMulti(products)
.toList()
}
4 -> {
cont.label = 5
val order = orderRepository.createOrderAsFuture(
).awaitSingle()
}
5 -> {
return order
}
}

Coroutines ; 최종 // 0 ->
// 1 ->
.awaitLast()
// 2 ->
val products = productRepository.findAllProductsByIdsAsFlux(productIds)
.toList()
// 3 ->
val stores = storeRepository.findStoresByProductsAsMulti(products)
.toList()
// 4 ->
val order = orderRepository.createOrderAsFuture(
).awaitSingle()
return order

Coroutines ; 실행 @Test
fun `should return a createdOrder in coroutine`() = runBlocking {
// given
// when
val inputValues = CreateOrderCoroutineUseCase.InputValues(userId, productIds)
watch.stop()
// then
}

03. 다음회 예고
Async를 사용한 동시성 처리 suspend fun execute(inputValues: InputValues): Order {
val addressDeferred = CoroutineScope(Dispatchers.IO).async {
.awaitLast()
}
val products =
productRepository.findAllProductsByIdsAsFlux(productIds).asFlow().toList()
val storesDeferred = CoroutineScope(Dispatchers.IO).async {
storeRepository.findStoresByProductsAsMulti(products).asFlow().toList()
}
val address = addressDeferred.await()
val stores = storesDeferred.await()
// 5. 주문 생성
- CoroutineDispatcher
- 여러 Thread를 오고가며 로직을
처리 가능

try/catch를 이용한 에러 핸들링 suspend fun execute(inputValues: InputValues): Order {
val buyer = try {
userRepository.findUserByIdAsMaybe(userId).awaitSingle()
} catch (e: Exception) {
throw NoSuchElementException("no such user")
}
.awaitLast()
// 5. 주문 생성
return order
}
- try/catch를 통해서 일관성 있게
에러 핸들링 가능

그 외에
- Structured concurrency
- Channel
- Flow

Kotlin coroutines 톺아보기

More Related Content

What's hot (20)

Similar to Kotlin coroutines 톺아보기 (15)

Recently uploaded (20)

Kotlin coroutines 톺아보기