Coroutine exceptions handling

https://kotlinlang.org/docs/exception-handling.html

Coroutine exceptions handling | Kotlin

위 링크를 공부하며 기록한 글이다

 

CoroutineExceptionHandler

익셉션 핸들러는 launch와 같은 코루틴빌더에서 발생하는 uncaught 예외에 대응할수있다. async와 같이 모든 예외를 사용자 단에서 처리할수 있는 경우에는 이 핸들러가 효과가 없다.

@OptIn(DelicateCoroutinesApi::class)
fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception -> 
        println("CoroutineExceptionHandler got $exception") 
    }
    val job = GlobalScope.launch(handler) { // root coroutine, running in GlobalScope
        throw AssertionError()
    }
    val deferred = GlobalScope.async(handler) { // also root, but async instead of launch
        throw ArithmeticException() // Nothing will be printed, relying on user to call deferred.await()
    }
    joinAll(job, deferred)    
}

Globalscope에서 root 코루틴 스코프로 쓰기위해 @OptIn 어노테이션이 필요하다. 이러면 job에서 발생한 uncaught 예외를 핸들러에서 처리해준다.

 

Cancellation and Exceptions

취소는 예외와 유사하다고 할 수 있다. 취소를 할때 코루틴은 CancellationException을 사용하기 때문인데, 이 예외는 따로 핸들러에서 처리되지않고 그냥 디버그 정보로 활용된다. 전파되지않는 예외처리이기 때문에 루트 코루틴 스코프까지 적용되지않고 cancel이 붙어있는 스코프만 취소시킨다.

 

하나 볼만한 코드가 있다.

val handler = CoroutineExceptionHandler { _, exception -> 
    println("CoroutineExceptionHandler got $exception") 
}
val job = GlobalScope.launch(handler) {
    launch { // the first child
        try {
            delay(Long.MAX_VALUE)
        } finally {
            withContext(NonCancellable) {
                println("Children are cancelled, but exception is not handled until all children terminate")
                delay(100)
                println("The first child finished its non cancellable block")
            }
        }
    }
    launch { // the second child
        delay(10)
        println("Second child throws an exception")
        throw ArithmeticException()
    }
}
job.join()

Long.MAX_VALUE면 일반적인 상황에서 굉장히 긴 시간인데 uncaught 예외를 던져서 강제로 스코프를 탈출시킨다.

이때 withContext는 따로 움직여서 이 스코프가 끝나야 핸들러에 있는 메시지가 출력된다.

 

Exceptions aggregation

예외처리 기본은 제일 처음에 발생한 것을 먼저 처리한다는 개념이다.

val handler = CoroutineExceptionHandler { _, exception ->
    println("CoroutineExceptionHandler got $exception")
}
val job = GlobalScope.launch(handler) {
    val inner = launch { // all this stack of coroutines will get cancelled
        launch {
            launch {
                throw IOException() // the original exception
            }
        }
    }
    try {
        inner.join()
    } catch (e: CancellationException) {
        println("Rethrowing CancellationException with original cause")
        throw e // cancellation exception is rethrown, yet the original IOException gets to the handler  
    }
}
job.join()

join에서 발생하는 IOException을 핸들러가 먼저 가져간다.

 

Supervision

SupervisorJob을 사용해 실패한 작업만 다시 시작하는 것과 같은 작업을 처리할 수 있다.

fun main() = runBlocking {
    val supervisor = SupervisorJob()
    with(CoroutineScope(coroutineContext + supervisor)) {
        // launch the first child -- its exception is ignored for this example (don't do this in practice!)
        val firstChild = launch(CoroutineExceptionHandler { _, _ ->  }) {
            println("The first child is failing")
            throw AssertionError("The first child is cancelled")
        }
        // launch the second child
        val secondChild = launch {
            firstChild.join()
            // Cancellation of the first child is not propagated to the second child
            println("The first child is cancelled: ${firstChild.isCancelled}, but the second one is still active")
            try {
                delay(Long.MAX_VALUE)
            } finally {
                // But cancellation of the supervisor is propagated
                println("The second child is cancelled because the supervisor was cancelled")
            }
        }
        // wait until the first child fails & completes
        firstChild.join()
        println("Cancelling the supervisor")
        supervisor.cancel()
        secondChild.join()
    }
}

슈퍼바이저를 캔슬했는데 secondChild로 전파되는 모습이 보인다.

fun main() = runBlocking {
    try {
        supervisorScope {
            val child = launch {
                try {
                    println("The child is sleeping")
                    delay(Long.MAX_VALUE)
                } finally {
                    println("The child is cancelled")
                }
            }
            // Give our child a chance to execute and print using yield 
            yield()
            println("Throwing an exception from the scope")
            throw AssertionError()
        }
    } catch(e: AssertionError) {
        println("Caught an assertion error")
    }
}

supervisorScope를 사용할 수도 있는데, uncaught예외가 루트까지 바로 안퍼지게 한다. 원래 예외가 양방향이었다면 슈퍼바이저 스코프에서는 단방향으로 적용돼서 AssertionError가 바로 runBlocking으로 가지않고 supervisorScope에서 먼저 처리되고, 부모스코프로 간다.

 

따라서 슈퍼바이저 스코프에서 직접 예외처리를 하려면 handler를 직접 넣어서 처리하면 된다. 이러면 루트스코프처럼 작동한다.

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception -> 
        println("CoroutineExceptionHandler got $exception") 
    }
    supervisorScope {
        val child = launch(handler) {
            println("The child throws an exception")
            throw AssertionError()
        }
        println("The scope is completing")
    }
    println("The scope is completed")
}

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