coroutines-cancellation-exceptions

Kotlin coroutine cancellation leaks or stuck jobs usually happen when suspending functions swallow CancellationException. Enforcing safe patterns with runCatching and ensureActive prevents silent cancellation and ensures proper job termination.

To handle exceptions in Kotlin coroutines without killing siblings, use supervisorScope to propagate failures independently. This structured concurrency boundary prevents a single child's exception from canceling other parallel tasks.

You perform suspending cleanup after a coroutine is cancelled by wrapping the cleanup logic in a NonCancellable region. This allows suspending operations to complete safely without being interrupted by the active cancellation state.

You should use runCatching in Kotlin suspend functions to safely wrap suspending work and catch exceptions. You must pair it with currentCoroutineContext().ensureActive() in failure handlers to rethrow CancellationException and avoid masking cancellation.

Structured concurrency in Kotlin relies on cooperative cancellation, meaning suspending functions must check for cancellation manually. Using ensureActive verifies the active state and rethrows CancellationException to stop execution immediately when cancelled.

The best way to rethrow CancellationException in Kotlin coroutines is calling currentCoroutineContext().ensureActive() inside your catch or runCatching failure blocks. This enforces safe cancellation patterns and prevents the exception from being swallowed.