CancellationException behavior in Kotlin - Step-by-Step Execution

Concept Flow - CancellationException behavior

Start Coroutine

↓

Check for Cancellation?

No→Continue Execution

Yes↓

Throw CancellationException

↓

Coroutine Cancelled

↓

Catch CancellationException?

Yes→Handle Cancellation

No↓

Propagate Exception

This flow shows how a coroutine checks for cancellation, throws CancellationException, and how it can be caught or propagated.

Execution Sample

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
  val job = launch(Dispatchers.Default) {
    delay(100)
    println("Still running")
  }
  job.cancel()
  job.join()
  println("Done")
}

This code launches a coroutine, cancels it before delay ends, and waits for completion.

Execution Table

Step	Action	Coroutine State	Exception Thrown	Output
1	Launch coroutine	Active	None
2	Start delay(100)	Active	None
3	Call job.cancel()	Cancelling	None
4	Coroutine checks cancellation during delay	Cancelling	CancellationException
5	Coroutine stops due to CancellationException	Cancelled	CancellationException
6	job.join() waits for coroutine completion	Cancelled	None
7	Print "Done"	Cancelled	None	Done

💡 Coroutine cancelled by CancellationException during delay, then job.join() completes and main prints "Done".

Variable Tracker

Variable	Start	After Step 1	After Step 3	After Step 5	Final
job.isActive	false	true	false	false	false
job.isCancelled	false	false	true	true	true
job.isCompleted	false	false	false	true	true

Key Moments - 2 Insights

Why does the coroutine stop even though no explicit exception handling is shown?

Because CancellationException is special in coroutines: it is thrown internally to stop the coroutine when cancelled, and it is not treated as a failure unless caught. See execution_table rows 4 and 5.

What happens if we do not call job.join() after cancelling?

Without job.join(), the main coroutine might finish before the launched coroutine fully cancels, causing unpredictable output timing. The join ensures the coroutine completes cancellation before continuing. See execution_table row 6.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what exception is thrown inside the coroutine?

A NullPointerException

B IllegalStateException

C CancellationException

D No exception

💡 Hint

Check the 'Exception Thrown' column at step 4 in the execution_table.

At which step does the coroutine state become 'Cancelled'?

A Step 4

B Step 5

C Step 3

D Step 7

💡 Hint

Look at the 'Coroutine State' column in the execution_table to find when it changes to 'Cancelled'.

If we remove job.join(), what is the likely effect on the output?

A "Done" might print before coroutine cancellation completes

B "Still running" will always print

C Program will crash with exception

D No change in output

💡 Hint

Refer to key_moments explanation about job.join() ensuring coroutine completion.

Concept Snapshot

CancellationException in Kotlin coroutines:
- Thrown internally when coroutine is cancelled
- Stops coroutine execution without failure
- Can be caught to handle cancellation
- Use job.cancel() to request cancellation
- Use job.join() to wait for coroutine to finish cancelling

Full Transcript

This visual trace shows how Kotlin coroutines handle cancellation using CancellationException. When a coroutine is cancelled, it throws CancellationException internally to stop execution. This exception is special and does not count as a failure unless caught. The example code launches a coroutine that delays for 100ms, but it is cancelled before delay ends. The coroutine throws CancellationException and stops. The main coroutine waits for cancellation to complete using job.join() before printing "Done". Variables track the coroutine state changes from active to cancelling to cancelled. Key moments clarify why the coroutine stops without explicit exception handling and why join() is important. The quiz tests understanding of when exceptions occur, state changes, and effects of removing join().

Practice

1. What is the primary purpose of CancellationException in Kotlin coroutines?

easy

A. To stop coroutines cleanly without treating it as an error

B. To indicate a syntax error in coroutine code

C. To force a coroutine to restart automatically

D. To log coroutine execution details

Solution

1. Step 1: Understand coroutine cancellation

   CancellationException is used to stop coroutines without throwing an error that crashes the program.

2. Step 2: Differentiate from errors

   Unlike other exceptions, CancellationException signals a normal cancellation, not a failure.

3. Final Answer:

   To stop coroutines cleanly without treating it as an error -> Option A

4. Quick Check:

   CancellationException stops coroutines cleanly [OK]

Hint: CancellationException means clean stop, not error [OK]

Common Mistakes:

• Confusing it with runtime errors
• Thinking it restarts coroutines
• Assuming it logs info automatically

2. Which of the following is the correct way to catch a CancellationException in Kotlin?

easy

A. catch (Error e) { /* handle */ }

B. catch (Exception e) { /* handle */ }

C. catch (Throwable e) { /* handle */ }

D. catch (CancellationException e) { /* handle */ }

Solution

1. Step 1: Identify exception type

   CancellationException is a specific exception type used for coroutine cancellation.

2. Step 2: Use specific catch block

   To handle cancellation properly, catch CancellationException explicitly.

3. Final Answer:

   catch (CancellationException e) { /* handle */ } -> Option D

4. Quick Check:

   Catch CancellationException explicitly [OK]

Hint: Catch CancellationException by its own type [OK]

Common Mistakes:

• Catching only Exception hides cancellation
• Using catch (Error) which is unrelated
• Catching Throwable catches too broadly

3. What will be the output of this Kotlin coroutine code snippet?

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(3) { i ->
                println("Working $i...")
                delay(100)
            }
        } catch (e: CancellationException) {
            println("Cancelled!")
        } finally {
            println("Cleanup done.")
        }
    }
    delay(150)
    job.cancelAndJoin()
    println("Done")
}

medium

A. Working 0...
Working 1...
Cancelled!
Cleanup done.
Done

B. Working 0...
Working 1...
Working 2...
Done

C. Cancelled!
Cleanup done.
Done

D. Working 0...
Cancelled!
Done

Solution

1. Step 1: Trace coroutine execution and cancellation

   The coroutine prints "Working 0..." and "Working 1..." with 100ms delay each, then cancellation occurs after 150ms.

2. Step 2: Handle CancellationException and finally block

   CancellationException is caught, printing "Cancelled!" and finally block prints "Cleanup done." before main prints "Done".

3. Final Answer:

   Working 0... Working 1... Cancelled! Cleanup done. Done -> Option A

4. Quick Check:

   CancellationException caught, cleanup runs, then Done [OK]

Hint: CancellationException triggers catch and finally blocks [OK]

Common Mistakes:

• Ignoring finally block output
• Assuming all repeats run before cancel
• Missing cancellation catch output

4. Identify the problem in this Kotlin coroutine snippet that tries to handle cancellation:

val job = launch {
    try {
        delay(1000)
    } catch (e: Exception) {
        println("Cancelled")
    }
}
job.cancel()

medium

A. The coroutine never starts because launch is missing parentheses

B. Calling job.cancel() without join causes a deadlock

C. It catches Exception instead of CancellationException, so cancellation is not handled properly

D. delay(1000) cannot be cancelled

Solution

1. Step 1: Check exception handling

   The catch block catches Exception, which includes CancellationException but does not distinguish it from other exceptions.

2. Step 2: Understand cancellation propagation

   To specifically handle cancellation without catching unrelated exceptions, catch CancellationException explicitly.

3. Final Answer:

   It catches Exception instead of CancellationException, so cancellation is not handled properly -> Option C

4. Quick Check:

   Catch CancellationException explicitly to handle cancellation [OK]

Hint: Catch CancellationException, not just Exception [OK]

Common Mistakes:

• Assuming Exception catch handles cancellation
• Thinking delay is uncancellable
• Confusing cancel() with deadlock

5. You want to cancel a coroutine but still perform some cleanup code without treating cancellation as an error. Which pattern correctly uses CancellationException to achieve this?

hard

A. Avoid catching exceptions and rely on coroutine scope cancellation only

B. Use try-catch with catch (CancellationException) to handle cancellation and run cleanup in finally

C. Use a global exception handler to catch all exceptions including cancellation

D. Use try-catch with catch (Exception) and ignore finally block

Solution

1. Step 1: Understand cancellation handling best practice

   CancellationException should be caught explicitly to avoid treating cancellation as failure.

2. Step 2: Use finally block for cleanup

   Cleanup code belongs in finally to ensure it runs whether coroutine completes or is cancelled.

3. Final Answer:

   Use try-catch with catch (CancellationException) to handle cancellation and run cleanup in finally -> Option B

4. Quick Check:

   Catch CancellationException and cleanup in finally [OK]

Hint: Catch CancellationException and cleanup in finally block [OK]

Common Mistakes:

• Catching only Exception hides cancellation
• Skipping finally block for cleanup
• Relying on global handlers for cancellation