Why is join() required to allow the catch part of a try catch to execute for an uncaught exception in Kotlin coroutines?

I have this code

fun caughtExceptionTest1() {
  runBlocking {
    try {
      launch { throwException() }.join()
    } catch (e: Exception) {
      // This prints
      print("caught Exception")
    }
  }
}

fun caughtExceptionTest2() {
  runBlocking {
    try {
      launch { throwException() }
    } catch (e: Exception) {
      // This does not print
      print("caught Exception")
    }
  }
}

Why does only caughtExceptionTest1 print "caught Exception"? I understand that the coroutines will be cancelled because throwException() is uncaught in the launch {} scope but why does the catch block only execute if we join() the Job that throws the exception?

The launch function is designed to be non-blocking(!), meaning it starts a coroutine but doesn't wait for its completion. So in caughtExceptionTest2 the try-catch finishes before the coroutine has a chance to throw an exception, and your exception doesn't get caught there

Meanwhile the join in caughtExceptionTest1 suspends the current coroutine until the one it's invoked on completes, meaning the try-catch block is still active when the exception occurs, allowing it to catch the exception

Read more: https://kotlinlang.org/docs/exception-handling.html

Note that your first test function is not catching the exception thrown by throwException() either. It will still escape the function and be thrown to the caller of caughtExceptionTest1(). You are only catching the CancellationException created by and thrown by your join() call.

The only difference between your two functions is that in the first one, you generate an extra Exception, the CancellationException, by calling join() and then immediately catch it and log it.

launch is designed to pass uncaught exceptions internal to the coroutine to its parent coroutine, so it doesn't throw it to the immediately surrounding code like you expected. The parent coroutine then handles it, and the behavior depends on what type of coroutine the parent is. In this case, the parent is the runBlocking coroutine, and it will rethrow the exception to the code that called runBlocking.