Como difere o tratamento de erros dentro de coroutines usando a construção try/catch do uso do CoroutineExceptionHandler?

No Kotlin, a gestão de erros em corrotinas pode ser feita de duas formas: através de try/catch dentro da própria corrotina e através de CoroutineExceptionHandler.

• try/catch dentro da corrotina permite capturar localmente as exceções que ocorrem no bloco de código da corrotina. É útil quando se deseja tratar o erro exatamente onde ele pode acontecer.

• CoroutineExceptionHandler é um manipulador global de exceções para corrotinas que terminam com erro e não foram capturadas localmente. Funciona apenas com corrotinas iniciadas com launch (que retornam um Job), e não com async (que retornam um Deferred), pois async requer uma chamada explícita a await para obter o resultado e tratar exceções.

Exemplo:

val handler = CoroutineExceptionHandler { _, exception ->
    println("Exceção capturada no CoroutineExceptionHandler: $exception")
}

GlobalScope.launch(handler) {
    try {
        // Código que pode lançar exceção
        throw RuntimeException("Erro dentro da corrotina")
    } catch (e: Exception) {
        println("Capturado localmente: $e")
    }
}

Se a exceção for capturada em try/catch, CoroutineExceptionHandler não será acionado. Se a exceção não for tratada localmente, ela será enviada ao CoroutineExceptionHandler. Assim, try/catch garante o tratamento local, enquanto que CoroutineExceptionHandler é global e serve para registrar ou realizar outras ações em caso de exceções não tratadas.