Coroutine Composing suspending functions

https://kotlinlang.org/docs/composing-suspending-functions.html

Composing suspending functions | Kotlin

위 링크를 공부하며 남기는 기록이다.

fun main() = runBlocking<Unit> {
    val time = measureTimeMillis {
        val one = doSomethingUsefulOne()
        val two = doSomethingUsefulTwo()
        println("The answer is ${one + two}")
    }
    println("Completed in $time ms")    
}

suspend fun doSomethingUsefulOne(): Int {
    delay(1000L) // pretend we are doing something useful here
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    delay(1000L) // pretend we are doing something useful here, too
    return 29
}

부모 코루틴 스코프의 실행시간은 자식 스코프의 실행시간도 모두 포함한다. measureTimeMillis는 내부 구문 실행시간을 반환하는 함수다.

 

Async

위 코드는 두 suspend fun과 코루틴 내부 코드가 순서대로 돌아간다. 따라서 실행시간이 약 2000ms으로 잡힌다. 이걸 원하지않는 경우가 있을텐데 async를 사용해 조작하는 방법이 있다. async를 사용하면 launch와 같이 코루틴을 생성하는 역할을 하기 때문에 동시에 작동시킬수 있다는 장점이 있고 launch는 값을 반환하는 시기를 조절하지 못하지만 async는 await()를 이용해서 연산시기를 조절할 수 있다는 장점이 있다.

val time = measureTimeMillis {
        val one = async { doSomethingUsefulOne() }
        val two = async { doSomethingUsefulTwo() }
        println("The answer is ${one.await() + two.await()}")
    }
println("Completed in $time ms")

이 코드의 실행시간은 약 1000ms이다. 

fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext, 
    start: CoroutineStart = CoroutineStart.DEFAULT, 
    block: suspend CoroutineScope.() -> T
): Deferred<T>

async의 구조인데 Deferred 인터페이스를 상속받아 사용한다. 이건 Job과 동일하게 작동하며 cancellable하다.

 

CoroutineStart.LAZY

val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
one.start()
two.start()

async의 파라미터에는 start가 있다. 이 파라미터를 CoroutineStart.LAZY로 지정하면 lazily하게 코루틴을 실행하게 되는데 이 경우 원래 active 상태를 반환하는 Deferred가 new 상태를 반환하게 된다. new 상태로 만들어진 이 Deferred(Job과 동일함을 기억)는  start, join, await를 호출할 때 active 상태로 변경된다. active 시점을 직접 결정할 수 있다는 것이 큰 장점이다. by lazy로 처음 사용할 때 초기화되는 것과 같이 작동하는 것으로 이해하면 될 것 같다.

 

LAZY를 사용하고 안하고의 실행시간 차이는 거의 없다. 그러나  new상태로 두면 사용이 불가능하고 start, join, await를 호출해 active상태로 바꿔주면 사용가능하다. 다만 조심해야될 것은 await는 코루틴을 실행하고 종료되는 것까지 포함하는 함수이기 때문에 미리 active로 바꾸지않으면 위와 같은 상황에서는 순차실행과 완전히 동일한 상황이 된다. 

Global scope

글로벌 스코프를 이용하면 suspend 를 안붙이고도 suspend fun을 만들 수 있다. @OptIn 어노테이션이 필요하지만 이렇게 하면 코루틴 밖에서 이 함수를 실행할 수 있게 된다.

// The result type of somethingUsefulOneAsync is Deferred<Int>
@OptIn(DelicateCoroutinesApi::class)
fun somethingUsefulOneAsync() = GlobalScope.async {
    doSomethingUsefulOne()
}

실행시간으로 보면 그냥 코루틴스코프 내에서 사용하는 것보다 100ms 더 느리다. 

 

글로벌 스코프는 앱 생명주기 전체에 존재하고 취소시킬 수 없다. 이런 형태는 메모리 누수와 같은 예기치 못한 오류를 낼 가능성이 있는데 이건 structured concurrency로 해결할 수 있다.

structured concurrency

코루틴의 제일 큰 개념인 structured concurrency이다. 자식 코루틴이 부모 코루틴안에서 존재하고, 자식코루틴에서 생겨난 예외가 부모까지 전파되는 형상을 이야기하며 스코프 안에서 다루기때문에 변수를 통제할 수 있다.

 

지금까지 적었던 코드를 함수화 시켜서 사용하는 것인데 one.await()+two.await()부분까지 함수로 뽑는 것이다.

suspend fun concurrentSum(): Int = coroutineScope {
    val one = async { doSomethingUsefulOne() }
    val two = async { doSomethingUsefulTwo() }
    one.await() + two.await()
}

val time = measureTimeMillis {
        println("The answer is ${concurrentSum()}")
    }

suspend fun 하나를 딱 호출하는 것으로 위 과정을 다 정리할 수 있다. 이 과정에서 exception도 다 전파된다.

"댓글, 공감 버튼 한 번씩 누르고 가주시면 큰 힘이 됩니다"