Job lifecycle and cancellation in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Job in Kotlin coroutines?

A Job represents a cancellable task or coroutine. It controls the coroutine's lifecycle, allowing you to start, cancel, or check its status.

intermediate

Name the main states in a Job's lifecycle.

The main states are:

• New: Created but not started.
• Active: Running or suspended.
• Completing: Finishing work.
• Cancelled: Stopped before completion.
• Completed: Finished successfully.

beginner

How do you cancel a Job in Kotlin?

You call the cancel() function on the Job instance. This requests cancellation, and the coroutine cooperatively stops if it checks for cancellation.

intermediate

What happens if a coroutine ignores cancellation?

If a coroutine does not check for cancellation (e.g., by calling yield() or checking isActive), it may continue running even after cancel() is called, delaying cancellation.

intermediate

Explain cooperative cancellation in Kotlin coroutines.

Cooperative cancellation means the coroutine must regularly check if it is cancelled and stop work accordingly. This is done by checking isActive or using cancellable suspending functions.

Which function is used to stop a running Job in Kotlin?

A cancel()

B stop()

C terminate()

D end()

The cancel() function requests cancellation of a Job.

What state is a Job in when it has finished successfully?

A Active

B Cancelled

C New

D Completed

A Job is Completed when it finishes its work successfully.

What must a coroutine do to respond to cancellation?

A Check for cancellation cooperatively

B Ignore cancellation requests

C Call cancel() on itself

D Run on a separate thread

Coroutines must cooperatively check for cancellation to stop execution.

Which of these is NOT a Job lifecycle state?

A New

B Active

C Paused

D Cancelled

There is no Paused state in Job lifecycle.

What happens if you call cancel() on a Job but the coroutine never checks for cancellation?

A The coroutine stops immediately

B The coroutine ignores cancellation and keeps running

C An error is thrown

D The Job restarts automatically

Without cooperative checks, the coroutine keeps running despite cancellation requests.

Describe the lifecycle of a Kotlin Job and how cancellation affects it.

Think about how a Job moves from new to completed or cancelled.

Explain why cooperative cancellation is important in Kotlin coroutines.

Consider what happens if a coroutine ignores cancellation.

Practice

1. Which of the following best describes the lifecycle of a Kotlin Job?

easy

A. A job is always active and never completes.

B. A job starts cancelled and then becomes active.

C. A job starts active, can be cancelled, and then completes.

D. A job completes before it starts.

Solution

1. Step 1: Understand Job lifecycle states

   A Kotlin Job begins in an active state, meaning it is running or ready to run.

2. Step 2: Recognize cancellation and completion

   A Job can be cancelled to stop its work, and after finishing or cancellation, it reaches a completed state.

3. Final Answer:

   A job starts active, can be cancelled, and then completes. -> Option C

4. Quick Check:

   Job lifecycle = active -> cancelled -> completed [OK]

Hint: Jobs start active, then cancel or complete [OK]

Common Mistakes:

• Thinking jobs start cancelled
• Assuming jobs never complete
• Confusing job states order

2. Which Kotlin code snippet correctly cancels a job and waits for its completion?

easy

A. job.cancelAndJoin()

B. job.cancel()

C. job.start()

D. job.join()

Solution

1. Step 1: Identify cancellation with waiting

   The method cancelAndJoin() cancels the job and suspends until it finishes.

2. Step 2: Differentiate from other methods

   cancel() only requests cancellation without waiting; join() waits but doesn't cancel; start() begins a job.

3. Final Answer:

   job.cancelAndJoin() -> Option A

4. Quick Check:

   Cancel and wait = cancelAndJoin() [OK]

Hint: Use cancelAndJoin() to cancel and wait [OK]

Common Mistakes:

• Using cancel() without waiting
• Confusing join() with cancel
• Calling start() to cancel

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

val job = CoroutineScope(Dispatchers.Default).launch {
    repeat(3) { i ->
        println("Working on $i...")
        delay(100)
    }
}
job.cancel()
Thread.sleep(500)

medium

A. Prints all three "Working on" lines

B. Prints some "Working on" lines before stopping

C. Throws a cancellation exception

D. Prints no output

Solution

1. Step 1: Analyze job launch and cancellation

   The job starts and prints "Working on 0...", then delays. The cancel() is called immediately after launch.

2. Step 2: Understand cancellation effect

   Because cancellation happens quickly, some iterations may run before the job stops, so partial output appears.

3. Final Answer:

   Prints some "Working on" lines before stopping -> Option B

4. Quick Check:

   Partial output due to quick cancel [OK]

Hint: Cancel stops job but may print partial output [OK]

Common Mistakes:

• Expecting all lines printed
• Expecting no output at all
• Assuming exception is printed

4. Identify the error in this Kotlin coroutine cancellation code:

val job = CoroutineScope(Dispatchers.Default).launch {
    try {
        repeat(5) {
            println("Working...")
            delay(100)
        }
    } catch (e: Exception) {
        println("Cancelled")
    }
}
job.cancelAndJoin()

medium

A. Missing job.start() before cancel

B. cancelAndJoin() should be called inside launch

C. delay() cannot be used inside launch

D. Catching Exception does not handle cancellation properly

Solution

1. Step 1: Understand cancellation exception type

   Cancellation throws CancellationException, which is a subclass of Throwable but not Exception.

2. Step 2: Recognize catch block limitation

   Since CancellationException is not caught by catch (e: Exception), the cancellation is not handled as intended.

3. Final Answer:

   Catching Exception does not handle cancellation properly -> Option D

4. Quick Check:

   Catch CancellationException, not Exception [OK]

Hint: Catch CancellationException, not Exception [OK]

Common Mistakes:

• Catching Exception instead of CancellationException
• Calling cancelAndJoin() incorrectly
• Thinking delay() is invalid inside launch

5. You want to safely cancel a long-running job and perform cleanup after cancellation. Which Kotlin coroutine pattern achieves this correctly?

hard

A. Use job.cancelAndJoin() then run cleanup code after it returns.

B. Call job.cancel() and immediately start a new job for cleanup.

C. Ignore cancellation and let the job finish naturally.

D. Call job.join() without cancelling, then cleanup.

Solution

1. Step 1: Understand safe cancellation

   Using cancelAndJoin() cancels the job and waits until it fully stops, ensuring no work is left running.

2. Step 2: Perform cleanup after cancellation

   After cancelAndJoin() returns, it's safe to run cleanup code because the job is fully cancelled.

3. Final Answer:

   Use job.cancelAndJoin() then run cleanup code after it returns. -> Option A

4. Quick Check:

   Cancel and wait before cleanup = cancelAndJoin() [OK]

Hint: Cancel and wait before cleanup with cancelAndJoin() [OK]

Common Mistakes:

• Starting cleanup before job stops
• Ignoring cancellation
• Using join() without cancelling