[3] Kotiln Coroutines - Suspending Function

Ref. ( 아래 유튜브 영상은 강력 추천 )

Youtube :  [새차원, 코틀린 코루틴] https://youtube.com/playlist?list=PLbJr8hAHHCP5N6Lsot8SAnC28SoxwAU5A

Ref : https://kotlinlang.org/

 

 

 

 

[ 간단 요약 ]

비동기도 순차적으로

 

순차적이지 않게 비동기적으로 - async

이중 Lazy 매개 변수에 대해서도 살펴 보았다. 

 

Structured concurrency 형태

> 스코프 안에서 코루틴을 실행시킨다면, 해당 코루틴들이 잘못되었을 때 캔슬이 전파 되면서 모든 코루틴을 종료할 수 있다는 점 주의!

 

---

 

☑️ 코루틴은 비동기 일지라도 순차적인 코드와 같다. (영상 08:20)

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

suspend fun doSomethingUsefulOne():Int{
    // 실제로 유용한 동작을 하는 부분으로 서버 호출 혹은 heavy 한 연산을 하는 부분.
    delay(1000L)
    return 13
}

suspend fun doSomethingUsefulTwo():Int{
    delay(1000L)
    return 29
}

코드 결과

>> 2000L 정도

 

 

 

 

 

☑️  독립적인 두가지를 두배 빠르게 할 수 있다. 명시적으로 (async 사용) 호출해야 한다.
- await 는 async 끝닐때까지 기다린다.
- 이런 것을 통해, 비동기로 코루틴을 호출한다던지 동기로 호출한다던지 자유자재로 사용할 수 있도록 익힌다.

 

두개의 연관이 없는 것을 어떻게 할 수 있는지를 알아보았다.

(요약 : async를 통해서 했고, deferred 객체가 반환되고 await를 통해서 할 수 있다.)

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

suspend fun doSomethingUsefulOne():Int{
    // 실제로 유용한 동작을 하는 부분으로 서버 호출 혹은 heavy 한 연산을 하는 부분.
    delay(1000L)
    return 13
}

suspend fun doSomethingUsefulTwo():Int{
    delay(1000L)
    return 29
}

코드 결과

>> 1000L 정도

 

 

 

 

☑️  async로 실행하는 코루틴을 어떻게 하면 나중에 실행 할 수 있게 할 수 있을까?
async 자체는 코루틴 빌더이다.

async()로 만들때 안의 매개 변수 start에 Lazy를 넣어주게 되면 바로 실행되지 않는다.

lazy가 넣어지면 start 를 해주거나 혹은 await를 해줄 때 이 코루틴이 실행되게 된다.

 

.start() 를 없애면 ? 2초가 걸림 : 왜일까.

코루틴 하나 만들고 또하나 만들었는데 start 하지 않았으니 await 를 만나게 되고,

one.await에서 실행되면 끝날때까지 기다렸다가 다음 코루틴이 실행 되기 때문.

 

fun main() = runBlocking {
    val time = measureTimeMillis {
        val one = async(start = CoroutineStart.LAZY) {doSomethingUsefulOne()}
        val two = async(start = CoroutineStart.LAZY) {doSomethingUsefulTwo()}
        one.start()
        two.start()
        println("The answer is ${one.await() + two.await()}")
    }
    kotlin.io.println("Completed in ${time} ms")
}

suspend fun doSomethingUsefulOne():Int{
    // 실제로 유용한 동작을 하는 부분으로 서버 호출 혹은 heavy 한 연산을 하는 부분.
    delay(1000L)
    return 13
}

suspend fun doSomethingUsefulTwo():Int{
    delay(1000L)
    return 29
}

 

 

 

 

☑️  Structured Concurrency with async

Global Scope 에서 Launch 하는 형태로 함수를 감싸서 만들지 말고,
Structured concurency 형태로 suspend 함수를 조합하고, 코루틴을 구성 하는게 낮다.

fun main() = runBlocking {
    val time = measureTimeMillis {
        println("The answer is ${concurrentSum()}")
    }
    println("Completed in ${time} ms")
}

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

    delay(10)
    println("exception")

    // throw Exception()

    one.await() + two.await()
}

suspend fun doSomethingUsefulOne():Int{
    println("start, doSomethingUsefulOne")
    delay(3000L) // 위의 exception 으로 cancel 을 이 delay에서
    println("end,doSomethingUsefulOne ")
    return 13
}

suspend fun doSomethingUsefulTwo():Int{
    kotlin.io.println("start, doSomethingUsefulTwo")
    delay(3000L)
    kotlin.io.println("end,doSomethingUsefulTwo ")
    return 29
}

 

 

 

 

☑️  Structured Concurrency 안에서 실행된 async 코루틴 2개가 있는데,

어떤 코루틴에서 Exception 이 발생했을 때, Exception이 발생되어서 코루틴이 Cancel 되면 Cancel 된 것들이 Hierarchy로 전파된다.

fun main() = runBlocking<Unit> {
    try{
        failedConcurrentSum()
    }catch (e: ArithmeticException){
        println("Computation failed with ArithmeticException")
    }
}

// 코루틴 two 에서 exception이 발생하면 다른 코루틴 one에 try~ catch~가되서 finally~ 블록이 찍히게 된다.
// 즉 정리하자면, 두 개의 다른 코루틴이 있었는데 최소가 전파된 것!
// and, 이것을 불러준 부모 코루틴이 있는데,  이 코루틴 내에서 (위에 runBlocking) 취소가 전파가 되어서 다시 try~ catch~ 되어서 잡히게 된다.

suspend fun failedConcurrentSum():Int = coroutineScope {
    val one = async<Int>{
        try{
            delay(Long.MAX_VALUE)
            42
        }finally {
            println("First child was cancelled")
        }
    }

    val two = async<Int> {
        println("Second child throws an exception")
        throw java.lang.ArithmeticException()
    }

    one.await() + two.await()
}