[Coroutine] 중단(suspend)의 작동 방식

 💡 코루틴에서 중단이 어떻게 동작하는지 학습하였습니다.

 

중단은 어떻게 작동할까?

• 중단 함수는 코틀린 코루틴의 핵심이 됩니다.
• 코루틴을 중단한다는 것은 실행을 중간에 멈추는 것을 의미합니다.
  • 체크포인트에 게임을 저장하고 다른 게임을 동작하는 것과 같으며, 사용자와 컴퓨터는 각각 다른 일에 집중할 수 있습니다.
  • 게임을 재개할 경우 저장한 체크포인터에서 실행한다면 이전에 종료했던 순간부터 게임을 즐길 수 있습니다.
• 코루틴은 중단되었을 때 Continuation 객체를 반환합니다.

스레드와의 차이점은?

• 스레드는 저장이 불가능하고, 멈추는 것만 가능합니다.
• 코루틴이 Continuation 객체를 반환하여 멈췄던 곳에서 다시 코루틴을 시작하지만 스레드는 저장이 불가능합니다.
• 코루틴은 또한 중단했을 때 어떤 자원도 사용하지 않으며, 다른 스레드에서 시작할 수 있습니다.
• 컨티뉴에이션 객체는 직렬화와 역직렬화가 가능하며 다시 실행될 수 있습니다.

재개

• 작업을 재개하려면 코루틴이 필요하며, runblocking이나 launch와 같은 코루틴 빌더를 활용할 수 있습니다.
• 중단 함수는 suspend 키워드를 활용하며, 반드시 코루틴에 의해 호출되어야 함을 의미합니다.

suspend fun main() {
    println("Before")
    println("After")
}
// Before
// After

• 만약 두 지점 사이를 중단하고 싶다면 suspendCoroutine 함수를 사용할 수 있습니다.

suspend fun main() {
    println("Before")
    suspendCoroutine<Unit> { continuation ->
        println("Before too")
    }
    println("After")
}
// Before
// Before too

• main 함수는 끝나지 않기 때문에, After는 출력되지 않습니다.
• suspendCoroutine 함수는 이 함수들과 같은 방식으로 설계되어 있어 중단되기 전에 컨티뉴에이션 객체를 사용할 수 있습니다.

continuation.resume(Unit) // Kotlin 1.3 이전
continuation.resumeWith(Unit) // Kotlin 1.3 이후

• 위 코드를 suspendCoroutine 내부에서 실행한다면, 중단된 코루틴을 바로 실행할 수 있습니다.
• 현재 resume과 resumeWithException 함수는 resumeWith을 사용하는 표준 라이브러리의 확장 함수가 되었습니다.

정지된 뒤 다른 스레드 실행

suspend fun main() {
    println("Before")
    suspendCoroutine<Unit> { continuation ->
        thread {
            println("Suspended")
            Thread.sleep(1000)
            continuation.resume(Unit)
            println("Resumed")
        }
    }
    println("After")
}
// Before
// Suspended
// ... 1초 후
// After
// Resumed

• 실제로는 중단 된 후 곧바로 실행되는 것이 아닌, 최적화로 인해 재개될 경우 아예 중단되지 않습니다.
• 하지만 만들어진 다음 1초 뒤에 사라지는 스레드는 불필요해 보이며, 스레드를 생성하는 비용을 생각했을 때 더 좋은 방법을 모색해야 합니다.

coroutine delay 구현

private val excutor =
    Executors.newSingleThreadScheduleExecutor {
        Thread(it, "scheduler").apply { isDaemon = true }
    }

suspend fun delay(timeMillis: Long): Unit =
    suspendCoroutine { cont ->
        executor.schedule({
            cont.resume(Unit)
        }, timeMillis, TimeUnit.MILLISECONDS)
    }

suspend fun main() {
    println("Before")
    delay(1000)
    println("After")
}
// Before
// 1초 후 ...
// After

• excutor에서 스레드를 활용하지만, delay 함수를 사용하는 모든 코루틴의 전용 스레드이며, 대기할 때마다 하나의 스레드를 블로킹하는 방법보다 훨씬 좋습니다.
• 실제 코루틴 라이브러리에서의 delay와 구현 방식이 정확히 일치하며, 테스트를 위해 delay를 구체화 하였습니다.

값으로 재개하기

• resume 함수는 Unit을 인자로 넣는데, 그 이유는 함수의 리턴 타입을 명시하는 것입니다.
• Unit은 Continuation의 제네릭 타입 인자로도 활용됩니다.

val ret: Unit =
    suspendCoroutine<Unit> { cont: Continuation<Unit> ->
        cont.resume(Unit)
    }

val i: Int = suspendCoroutine<Int> { cont ->
    cont.resume(42)
}

• 위와 같이 타입을 지정하는 것도 가능하며, 타입을 지정하는 경우는 resume을 통해 반환되는 타입이 지정 타입과 반드시 같아야 합니다.
• 값으로 재개하는 상황은 지정한 곳에서 재개할 때 기존과 다른 무엇인가를 추가하는 것은 어렵습니다.
• 하지만 코루틴에서는 값으로 재개하는 것을 자연스럽게 처리할 수 있습니다.

코루틴의 값으로 재개하기

• API를 호출해 네트워크 응답을 기다리는 등의 특정 데이터를 위한 중단은 자주 발생합니다.
• 이러한 상황에서 코루틴이 없다면 스레드는 응답을 기다리는 상황만 가능해집니다.
• 스레드를 생성하는 비용이 많이 들며, 안드로이드처럼 메인 스레드가 중요하게 적용하는 경우 매우 큰 낭비로 이어질 수 있습니다.
• “데이터를 받고 나면, 받은 데이터를 resume으로 전송해라”와 같은 Continuation 객체를 통해 라이브러리에 전달한다면, 스레드는 중간에 다른 일을 할 수 있습니다.
• 그 후 데이터가 도착하면 스레드는 코루틴이 중단된 지점에서 재개할 수 있습니다.

suspend fun main() {
    println("Before")
    val user = suspendCoroutine<User> { cont ->
        requestUser { user ->
            cont.resume(user)
        }
    }
    println(user)
    println("After")
}
// Before
// 데이터를 받는 시간 경과
// User(name = Test)
// After

• 위 경우 특정 데이터를 얻을 때까지 중단되는 상황을 얻을 수 있으며, 스레드가 응답을 기다리지 않고, 다른일을 처리할 수 있습니다.
• user 객체가 도착한다면, 스레드는 코루틴이 중단된 시점에서 재개되어 사용자가 원하는 값을 기대할 수 있습니다.

예외로 재개하기

• 만약 API가 데이터를 넘겨주는 과정에서 에러가 발생한다면, 데이터를 반환할 수 없으므로 코루틴이 중단된 곳에서 예외를 발생시켜야 합니다.

class MyException : Throwable("custom exception")

suspend fun main() {
    try {
        suspendCoroutine<Unit> { cont ->
            cont.resumeWithException(MyException())
        }
    } catch (e: MyException) {
        println("${e.message}")
    }
}

함수가 아닌 코루틴을 중단

• 중단 함수는 코루틴이 아닌, 단지 코루틴을 중단할 수 있는 함수라 할 수 있습니다.

var continuation: Continuation<Unit>? = null

suspend fun suspendAndSetContinuation() {
    suspendCoroutine<Unit> { cont ->
        continuation = cont
    }
}

suspend fun main(){
    println("Before")
    suspendAndSetContinuation()
    continuation?.resume(Unit)
    println("After")
}
// Before

• 위 코드는 잘못 된 구현을 예시로 들고 있습니다.
• 의도와 달리 종료되지 않으며, resume이 호출되지 않았습니다.
• 그 이유는 suspendAndSetContinuation()를 통해 중단 지점을 생성하고 코루틴을 일시 중단 하였지만, continuation이 다시 호출되기 전까지 코루틴이 재개되지 않습니다.
• continuation?.resume(Unit)를 통해서 코루틴을 재개하지만, 이 코드는 아직 main 함수의 일시 중단된 지점에서 재개되지 않았습니다.
• main 함수가 비동기적으로 동작하고, continuation?.resume(Unit)이 호출되기 전에 프로그램이 종료되었기 때문이며, resume()의 호출은 main 함수가 종료되기 전에 완료되지 않았습니다.
• 이는 메모리 누수가 발생할 수 있습니다.

var continuation: Continuation<Unit>? = null

suspend fun suspendAndSetContinuation() {
    suspendCoroutine<Unit> { cont ->
        continuation = cont
    }
}

fun main() = runBlocking {
    println("Before")
    suspendAndSetContinuation()
    continuation?.resume(Unit)
    println("After")
}

• 위와 같이 runBlocking을 활용하여 main 함수가 코루틴의 완료를 기다리게 한다면 문제를 해결할 수 있습니다.

https://m.yes24.com/Goods/Detail/123034354

코틀린 코루틴 - 예스24