Job lifecycle and cancellation in Kotlin

Introduction

Jobs help manage background tasks in Kotlin. Understanding their lifecycle and how to stop them safely keeps your app responsive and efficient.

When running a task in the background that might take time, like downloading a file.

When you want to stop a task early if the user leaves the screen.

When you need to clean up resources after a task finishes or is stopped.

When coordinating multiple tasks that depend on each other.

When you want to avoid wasting battery or CPU on tasks no longer needed.

Syntax

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    // your background task here
}

// To cancel the job:
job.cancel()

// To check if job is active:
if (job.isActive) {
    // do something
}

launch starts a new job (background task).

cancel() stops the job safely.

Examples

This starts a job that prints messages but cancels it immediately, so "Job finished" may not print.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    println("Job started")
    delay(1000)
    println("Job finished")
}

job.cancel()

This runs a job that prints steps but cancels it after 1 second.

Kotlin

val job = CoroutineScope(Dispatchers.Default).launch {
    repeat(5) { i ->
        println("Working on step $i")
        delay(500)
    }
}

// Cancel after 1 second
CoroutineScope(Dispatchers.Default).launch {
    delay(1000)
    job.cancel()
    println("Job cancelled")
}

Sample Program

This program starts a job that prints steps every 0.5 seconds. After about 1.2 seconds, it cancels the job. The job catches the cancellation, prints a message, and does cleanup. Finally, the main program confirms the job is done.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            repeat(5) { i ->
                println("Working on step $i")
                delay(500)
            }
        } catch (e: CancellationException) {
            println("Job was cancelled")
        } finally {
            println("Cleanup after job")
        }
    }

    delay(1200) // Let the job run a bit
    println("Requesting cancellation")
    job.cancelAndJoin() // Cancel and wait for job to finish
    println("Job is completed: ${job.isCompleted}")
}

Important Notes

Always handle CancellationException inside jobs to clean up resources.

Calling cancel() requests cancellation but does not wait; use cancelAndJoin() to wait until the job finishes.

A job is isActive while running and isCompleted after finishing or cancellation.

Summary

Jobs represent background tasks with a clear lifecycle: active, cancelled, completed.

You can stop jobs safely using cancel() or cancelAndJoin().

Handling cancellation lets you clean up and keep your app responsive.

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