[Coroutine] 코루틴 예외 처리

 💡 코루틴의 작동 원리 중 아주 중요한 기능인 코루틴 예외 처리에 대하여 학습하였습니다.

예외 처리

• 잡히지 않는 예외가 발생하면 프로그램이 종료되는 것처럼, 코루틴도 잡히지 않은 예외가 발생했을 때 종료됩니다.
• 큰 차이는 코루틴 빌더는 부모도 종료시키며, 취소된 부모는 자식들 모두를 취소시킵니다.

fun main(): Unit = runBlocking {
    launch {
        launch {
            delay(1000)
            throw Error("Error")
        }

        launch {
            delay(2000)
            println("Will not be printed")
        }

        launch {
            delay(500)
            println("Will be printed")
        }
    }

    launch {
        delay(2000)
        println("Will not be printed")
    }
}
// Will be printed
// Exception in thread "main" java.lang.Error: Some error...

• 예외는 자식에서 부모로 전파되며, 부모가 취소되면 자식도 취소되기 때문에 쌍방으로 전파됩니다.
• 예외 전파가 정지되지 않으면, 계통 구조상 모든 코루틴이 취소되게 됩니다.

코루틴 종료 멈추기

• 코루틴 간의 상호작용은 잡을 통해서 일어나기 때문에, 코루틴 빌더 내부에서 새로운 코루틴 빌더를 try-catch 문을 통해 래핑하는 건 전혀 도움이 되지 못합니다.
• 이를 해결하기 위해서 예외 전파를 멈추는 방법에 대하여 알아보겠습니다.

SupervisorJob

• supervisorJob을 사용하면, 자식에서 발생한 모든 예외를 무시할 수 있습니다.

• 부모 혹은 다른 자식들에게 자신의 예외가 영향을 미치지 않습니다.

val scope = CoroutineScope(SupervisorJob())
scope.launch {
    // child1
}
scope.launch {
    // child2
}

• 위 코드에서 child1에서 예외가 발생해도 child2로 예외가 전파되지 않습니다.
• SupervisorJob을 사용할 때 가장 흔한 실수는 부모 코루틴이 없이 SupervisorJob을 활용하는 것입니다.

fun main(): Unit = runBlocking {
    // 부모 코루틴이 없는 잡은 일반 잡과 동일하게 작동
    launch(SupervisorJob()) {
        launch {
            throw Error("error")
        }
    }
}
// Exception

• 하나의 코루틴이 취소되어도 다른 코루틴이 취소되지 않는다는 특징을 가지고 있기 때문에 같은 잡을 다수의 코루틴에서 컨텍스트로 사용하는 것이 좀 더 좋은 방법이라고 할 수 있습니다.

val job = SupervisorJob()
launch(job) {
    throw Error("Error1")
}
launch(job) {
    throw Error("Error2")
}

supervisorScope

• 코루틴 빌더를 supervisorScope로 래핑하는 방법도 있습니다.
• 이 방식은 다른 코루틴에서 발생한 예외를 무시하고 부모와의 연결을 유지합니다.

// in runBlocking
supervisorScope {
    launch {
        throw Error("error")
    }
    launch {
        throw Error("error")
    }
}

• 이는 단지 중단 함수일 뿐이며, 중단 함수 본체를 래핑하는 데 사용됩니다.
• 일반적으로 서로 무관한 다수의 작업을 스코프 내에서 실행할 때 활용할 수 있습니다.

suspend fun notifyAnalytics(actions: List<UserAction>) =
    supervisorScope {
        actions.forEach { action ->
            launch {
                notifyAnalytics(action)
            }
        }
    }

• 여기서 주의할 점은 supervisorScope는 withContext(SupervisorJob())으로 대체될 수 없습니다.

// 잘못 된 코드입니다 !
suspend fun notifyAnalytics(actions: List<UserAction>) = 
		withContext(SupervisorJob()) {}

• 위 코드는 Job이 상속되지 않는 유일한 컨텍스트이기 때문에 문제가 발생합니다.
• 코루틴은 각자 자신만의 잡을 가지고 있고, 잡을 다른 코루틴에 전달하여 부모 관계를 맺습니다.
• 위 코드에서는 예외 발생 시 withContext 코루틴으로 전달되며, 부모와 자식 코루틴이 모두 취소되어 마지막으로 예외가 던져집니다.
• 이는 SupervisorJob을 부모로 바꾸어도 원하는 효과를 얻을 수 없습니다.

await

• 예외가 발생했을 때 async 코루틴 빌더는 launch처럼 부모 코루틴을 종료하고 부모와 관련있는 다른 코루틴 빌더도 종료시킵니다.

suspend fun main() = supervisorScope {
    val str1 = async<String> {
        throw Exception()
    }
    val str2 = async {
        "Text2"
    }
    try {
        println(str1.await())
    } catch( e: Exception) {
        println(e)
    }

    println(str2.await())
}
// Exception
// Text2

• 코루틴이 예외로 종료되었기 때문에 반환할 값이 없지만, await가 Exception을 던져서 Exception이 출력됩니다.
• supervisorScope가 사용되었기 때문에 또 다른 async는 중단되지 않고 끝까지 실행됩니다.

CancellationException

• 예외가 CancellationException의 서브클래스라면 부모로 전파되지 않고, 현재 코루틴 취소만 진행합니다.
• CancellationException은 열린 클래스이기 때문에 다른 클래스나 객체로 확장될 수 있습니다.

object MyException : CancellationException()

suspend fun main(): Unit = coroutineScope {
    launch { // 1 coroutine
        launch { // 2 coroutine
            delay(2000)
            println("not be printed")
        }
        throw MyException
    }
    launch { // 3 coroutine
        delay(2000)
        println("be printed")
    }
}
// 2초 후..
// be printed

• 두 개의 코루틴이 1, 3 빌더로 시작됩니다.
• 1에서 CancellationException의 예외인 MyException를 던지므로, 예외는 1에서 시작된 launch에서 잡히게 됩니다.
• 1에서 시작된 코루틴은 자기 자신과 자식인 2 빌더를 취소하고, 3 빌더는 아무런 영향을 받지 않고 정상적으로 실행됩니다.

코루틴 예외 핸들러

• 예외를 다룰 때 예외를 처리하는 기본 행동을 정의하는 것이 유용합니다.
• 코루틴에서는 이런 경우에 CoroutineExceptionHandler 컨텍스트를 사용할 수 있으며, 예외 전파를 중단시키지 않고 예외가 발생할 때 해야할 것들을 정의하는 데 사용합니다.

fun main(): Unit = runBlocking {
    val handler =
        CoroutineExceptionHandler { ctx, exception ->
            println("Caught $exception")
        }
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch {
        delay(1000)
        throw Error("Error")
    }

    delay(3000)
}
// Caught java.lang.Error: Error

참고

https://tak8997.github.io/2021/04/17/Kotlin-Coroutine-Exception-Handling/