Job lifecycle and cancellation in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to wait for a coroutine job to complete.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    println("Job started")
}
job.[1]

Drag options to blanks, or click blank then click option'

Astart()

Bjoin()

Ccancel()

Dinvoke()

Attempts:

3 left

💡 Hint

Common Mistakes

Using cancel() instead of join() will stop the job instead of waiting.

start() is not needed because launch starts the job immediately.

The join() function waits for the coroutine job to complete.

2fill in blank

medium

Complete the code to cancel a running coroutine job.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    repeat(1000) { i ->
        println("Job is working on task $i")
        delay(100L)
    }
}
job.[1]

Drag options to blanks, or click blank then click option'

Acancel()

Bstart()

Cjoin()

Dinvoke()

Attempts:

3 left

💡 Hint

Common Mistakes

Using join() waits for completion but does not cancel.

start() is not used to stop a job.

The cancel() function stops the coroutine job.

3fill in blank

hard

Fix the error in the code to check if a job is active.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    delay(1000L)
}
if (job.[1]) {
    println("Job is still active")
}

Drag options to blanks, or click blank then click option'

AisCompleted

BisCancelled

CisActive

DisRunning

Attempts:

3 left

💡 Hint

Common Mistakes

Using isCancelled checks if the job was cancelled, not if active.

isCompleted means the job finished, not active.

The isActive property tells if the job is currently running.

4fill in blank

hard

Fill both blanks to create a coroutine that cancels itself after delay.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    delay(500L)
    job.[1]()
}
job.[2]()

Drag options to blanks, or click blank then click option'

Acancel

Bjoin

Cstart

Dinvoke

Attempts:

3 left

💡 Hint

Common Mistakes

Using start() instead of cancel() inside coroutine.

Not waiting for job completion with join().

The coroutine calls cancel() to stop itself, and the main code waits with join().

5fill in blank

hard

Fill all three blanks to create a job that checks cancellation and handles it.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    try {
        repeat(100) {
            if (!job.[1]) {
                println("Job cancelled")
                return@launch
            }
            println("Working on task $it")
            delay(100L)
        }
    } catch (e: [2]) {
        println("Caught cancellation exception")
    }
}
job.[3]()

Drag options to blanks, or click blank then click option'

AisActive

BCancellationException

Cjoin

DisCancelled

Attempts:

3 left

💡 Hint

Common Mistakes

Checking isCancelled instead of isActive.

Catching wrong exception type.

Not waiting for job completion.

The job checks isActive to detect cancellation, catches CancellationException, and the main code waits with join().

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