Exception handling in coroutines in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Coroutine Exception Propagation

What happens when an exception is thrown inside a launch coroutine builder without a try-catch block?

A The exception is propagated to the parent coroutine and can cancel the entire scope.

B The exception is silently ignored and the coroutine completes normally.

C The exception is caught automatically and logged without affecting other coroutines.

D The exception causes the app to crash immediately without any propagation.

💡 Hint

Think about how structured concurrency manages errors in coroutines.

In Kotlin coroutines, exceptions thrown in a launch coroutine propagate to the parent scope and can cancel sibling coroutines. This is part of structured concurrency to avoid silent failures.

❓ ui_behavior

intermediate

Effect of Exception in async Coroutine

Consider this code snippet:

val deferred = async {
  throw IllegalStateException("Error")
}

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

What will be printed when this code runs?

A No output, the exception is ignored.

B Caught: null

C The app crashes with IllegalStateException.

D Caught: Error

💡 Hint

Remember that async exceptions are deferred until await() is called.

Exceptions inside async coroutines are captured and only thrown when await() is called. The try-catch around await() catches the exception and prints the message.

❓ lifecycle

advanced

Handling Exceptions with CoroutineExceptionHandler

Given this code:

val handler = CoroutineExceptionHandler { _, exception ->
  println("Caught by handler: ${exception.message}")
}

val job = GlobalScope.launch(handler) {
  throw RuntimeException("Failure")
}

runBlocking { job.join() }

What will be printed?

A Caught by handler: Failure

B No output, exception is ignored.

C The app crashes with RuntimeException.

D Caught by handler: null

💡 Hint

Check how CoroutineExceptionHandler works with launch coroutines.

CoroutineExceptionHandler catches uncaught exceptions in launch coroutines. The handler prints the exception message when the coroutine throws.

🔧 Debug

advanced

Why Does This Coroutine Exception Crash the App?

Analyze this code:

runBlocking {
  val job = launch {
    throw ArithmeticException("Divide by zero")
  }
  job.join()
  println("Coroutine finished")
}

What happens when this runs?

A The exception is caught internally and "Coroutine finished" is printed.

B The app crashes with ArithmeticException and "Coroutine finished" is not printed.

C "Coroutine finished" is printed and the exception is ignored.

D The exception is logged but the app continues normally.

💡 Hint

Consider how exceptions in launch coroutines affect the parent scope.

Exceptions in launch coroutines are propagated and cancel the parent scope unless caught. Here, no catch block exists, so the app crashes and the print statement is skipped.

🧠 Conceptual

expert

Exception Handling Differences Between launch and async

Which statement correctly describes the difference in exception handling between launch and async coroutines?

A Both <code>launch</code> and <code>async</code> defer exceptions until their job is joined.

B <code>async</code> immediately throws exceptions to the parent, while <code>launch</code> defers exceptions until <code>join()</code> is called.

C <code>launch</code> immediately throws exceptions to the parent, while <code>async</code> defers exceptions until <code>await()</code> is called.

D Neither <code>launch</code> nor <code>async</code> propagate exceptions to the parent coroutine.

💡 Hint

Think about when exceptions become visible in each coroutine builder.

launch coroutines propagate exceptions immediately to their parent, potentially cancelling sibling coroutines. async coroutines capture exceptions and only throw them when await() is called.