Exception Handling

1. Giới thiệu

Exception handling trong coroutines khác với code thông thường do structured concurrency. Exceptions propagate theo hierarchy và có thể cancel siblings.

2. Basic Exception Handling

try-catch trong coroutine

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        try {
            riskyOperation()
        } catch (e: Exception) {
            println("Caught in coroutine: ${e.message}")
        }
    }
}

suspend fun riskyOperation() {
    delay(100)
    throw RuntimeException("Something went wrong!")
}

try-catch KHÔNG work xung quanh launch

import kotlinx.coroutines.*

fun main() = runBlocking {
    // ❌ KHÔNG catch được exception từ launch
    try {
        launch {
            throw RuntimeException("Failed!")
        }
    } catch (e: Exception) {
        println("This won't catch it!")
    }

    delay(100)
    println("This might not print due to uncaught exception")
}

3. CoroutineExceptionHandler

Handler cuối cùng cho uncaught exceptions:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { context, exception ->
        println("Caught in handler: ${exception.message}")
        println("Coroutine: ${context[CoroutineName]}")
    }

    val scope = CoroutineScope(SupervisorJob() + handler + CoroutineName("MainScope"))

    scope.launch(CoroutineName("FailingJob")) {
        throw RuntimeException("Oops!")
    }

    scope.launch(CoroutineName("SuccessJob")) {
        delay(100)
        println("This still runs with SupervisorJob!")
    }

    delay(200)
}
// Output:
// Caught in handler: Oops!
// Coroutine: CoroutineName(FailingJob)
// This still runs with SupervisorJob!

Handler rules

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, e ->
        println("Handler: ${e.message}")
    }

    // ✅ Handler works with launch
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch {
        throw RuntimeException("launch exception")
    }

    delay(100)

    // ❌ Handler KHÔNG work với async - dùng try-catch với await()
    val deferred = scope.async {
        throw RuntimeException("async exception")
    }

    try {
        deferred.await()
    } catch (e: Exception) {
        println("Caught from async: ${e.message}")
    }
}

4. Exception Propagation

Default behavior: fail fast

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        coroutineScope {
            launch {
                delay(50)
                throw RuntimeException("Child 1 failed")
            }

            launch {
                try {
                    delay(Long.MAX_VALUE)
                } catch (e: CancellationException) {
                    println("Child 2 cancelled due to sibling failure")
                    throw e  // Re-throw to complete cancellation
                }
            }
        }
    } catch (e: RuntimeException) {
        println("Parent caught: ${e.message}")
    }
}
// Output:
// Child 2 cancelled due to sibling failure
// Parent caught: Child 1 failed

SupervisorScope: isolate failures

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, e ->
        println("Handler caught: ${e.message}")
    }

    supervisorScope {
        launch(handler) {
            delay(50)
            throw RuntimeException("Child 1 failed")
        }

        launch {
            delay(100)
            println("Child 2 completed successfully!")
        }
    }

    println("Supervisor scope completed")
}
// Output:
// Handler caught: Child 1 failed
// Child 2 completed successfully!
// Supervisor scope completed

5. async Exception Handling

import kotlinx.coroutines.*

fun main() = runBlocking {
    // async defers exception until await()
    val deferred = async {
        delay(100)
        throw RuntimeException("Async failed")
    }

    // Exception thrown here
    try {
        val result = deferred.await()
    } catch (e: RuntimeException) {
        println("Caught at await: ${e.message}")
    }
}

Parallel async với error handling

import kotlinx.coroutines.*

suspend fun fetchAllData(): Result<Data> = coroutineScope {
    try {
        val users = async { fetchUsers() }
        val posts = async { fetchPosts() }

        Result.success(Data(users.await(), posts.await()))
    } catch (e: Exception) {
        Result.failure(e)
    }
}

data class Data(val users: List<String>, val posts: List<String>)

suspend fun fetchUsers(): List<String> {
    delay(100)
    return listOf("Alice", "Bob")
}

suspend fun fetchPosts(): List<String> {
    delay(150)
    throw RuntimeException("Network error!")
}

fun main() = runBlocking {
    when (val result = fetchAllData()) {
        is Result -> result.fold(
            onSuccess = { println("Data: $it") },
            onFailure = { println("Error: ${it.message}") }
        )
    }
}
// Output: Error: Network error!

6. CancellationException

Cancellation là đặc biệt - không được coi là failure:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, e ->
        println("Handler: ${e.message}")  // NOT called for cancellation
    }

    val job = launch(handler) {
        try {
            delay(Long.MAX_VALUE)
        } catch (e: CancellationException) {
            println("Caught cancellation: ${e.message}")
            throw e  // Re-throw is OK (và recommended)
        }
    }

    delay(100)
    job.cancel(CancellationException("Cancelled by user"))
    job.join()

    println("Job cancelled, but no exception handler called")
}
// Output:
// Caught cancellation: Cancelled by user
// Job cancelled, but no exception handler called

Cancellation trong finally

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            delay(Long.MAX_VALUE)
        } finally {
            // Cleanup code
            println("Cleaning up...")

            // ❌ Suspending calls throw here normally
            // delay(100)  // throws CancellationException

            // ✅ Use withContext(NonCancellable) for cleanup
            withContext(NonCancellable) {
                delay(100)
                println("Cleanup complete")
            }
        }
    }

    delay(100)
    job.cancelAndJoin()
}

7. Retry Patterns

Simple retry

import kotlinx.coroutines.*

suspend fun <T> retry(
    times: Int = 3,
    delayMs: Long = 1000,
    block: suspend () -> T
): T {
    var lastException: Exception? = null

    repeat(times) { attempt ->
        try {
            return block()
        } catch (e: Exception) {
            lastException = e
            println("Attempt ${attempt + 1} failed: ${e.message}")
            if (attempt < times - 1) {
                delay(delayMs)
            }
        }
    }

    throw lastException!!
}

suspend fun unreliableCall(): String {
    if (Math.random() < 0.7) {
        throw RuntimeException("Network error")
    }
    return "Success!"
}

fun main() = runBlocking {
    try {
        val result = retry(times = 5, delayMs = 500) {
            unreliableCall()
        }
        println("Result: $result")
    } catch (e: Exception) {
        println("All attempts failed: ${e.message}")
    }
}

Exponential backoff

import kotlinx.coroutines.*
import kotlin.math.pow

suspend fun <T> retryWithBackoff(
    times: Int = 3,
    initialDelayMs: Long = 100,
    maxDelayMs: Long = 10000,
    factor: Double = 2.0,
    block: suspend () -> T
): T {
    var currentDelay = initialDelayMs

    repeat(times - 1) { attempt ->
        try {
            return block()
        } catch (e: Exception) {
            println("Attempt ${attempt + 1} failed, retrying in ${currentDelay}ms")
            delay(currentDelay)
            currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelayMs)
        }
    }

    return block()  // Last attempt
}

8. Flow Error Handling

catch operator

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun riskyFlow(): Flow<Int> = flow {
    emit(1)
    emit(2)
    throw RuntimeException("Flow error!")
    emit(3)  // Never reached
}

fun main() = runBlocking {
    riskyFlow()
        .catch { e ->
            println("Caught: ${e.message}")
            emit(-1)  // Emit fallback value
        }
        .collect { println("Value: $it") }
}
// Output:
// Value: 1
// Value: 2
// Caught: Flow error!
// Value: -1

retry operator

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

var attempts = 0

fun unreliableFlow(): Flow<Int> = flow {
    attempts++
    if (attempts < 3) {
        throw RuntimeException("Attempt $attempts failed")
    }
    emit(42)
}

fun main() = runBlocking {
    unreliableFlow()
        .retry(3) { e ->
            println("Retrying due to: ${e.message}")
            delay(100)
            true  // true = retry, false = don't retry
        }
        .catch { println("All retries failed: ${it.message}") }
        .collect { println("Result: $it") }
}
// Output:
// Retrying due to: Attempt 1 failed
// Retrying due to: Attempt 2 failed
// Result: 42

9. Best Practices

import kotlinx.coroutines.*

// ✅ Handle exceptions at the right level
class Repository {
    suspend fun fetchData(): Result<Data> {
        return try {
            Result.success(actualFetch())
        } catch (e: NetworkException) {
            Result.failure(e)
        }
    }
}

// ✅ Use supervisorScope for independent tasks
suspend fun loadDashboard() = supervisorScope {
    val news = async { fetchNews() }      // Independent
    val weather = async { fetchWeather() } // Independent

    DashboardData(
        news = runCatching { news.await() }.getOrDefault(emptyList()),
        weather = runCatching { weather.await() }.getOrNull()
    )
}

// ✅ Always handle CancellationException properly
suspend fun doWork() {
    try {
        // work
    } catch (e: CancellationException) {
        // Cleanup if needed
        throw e  // Always re-throw!
    } catch (e: Exception) {
        // Handle other exceptions
    }
}

// ✅ Use NonCancellable for critical cleanup
suspend fun saveAndClose(resource: Resource) {
    try {
        resource.use()
    } finally {
        withContext(NonCancellable) {
            resource.save()
            resource.close()
        }
    }
}

10. Summary Table

Scope	Exception Behavior
coroutineScope	One fails -> all cancel
supervisorScope	Failures isolated
launch	Propagates to parent
async	Deferred until await()

Handler	Works with
try-catch	Inside coroutine, or around await()
CoroutineExceptionHandler	launch (not async)
Flow catch	Flow emissions

---

📝 Tóm tắt

• Dùng try-catch bên trong coroutines hoặc xung quanh await()
• CoroutineExceptionHandler cho uncaught exceptions từ launch
• supervisorScope khi tasks độc lập
• CancellationException nên được re-throw
• NonCancellable cho critical cleanup
• Flow: dùng catch và retry operators