Job lifecycle and cancellation in Kotlin - Mini Project: Build & Apply

Job lifecycle and cancellation

📖 Scenario: You are building a simple Kotlin program that uses coroutines to run a background task. You want to understand how to start a job, check its status, and cancel it properly.

🎯 Goal: Learn how to create a coroutine Job, check if it is active or completed, and cancel it safely.

📋 What You'll Learn

Create a coroutine Job that runs a simple repeating task

Add a variable to hold the Job

Use coroutine lifecycle properties like isActive and isCompleted

Cancel the Job and print its status

💡 Why This Matters

🌍 Real World

Understanding job lifecycle and cancellation is important when running background tasks in Android apps or server applications to avoid wasting resources.

💼 Career

Many Kotlin developer roles require knowledge of coroutine management to write efficient and responsive asynchronous code.

1

Create a coroutine Job with a repeating task

Write code to create a coroutine Job named job that runs a repeating task printing "Working..." every 300 milliseconds inside a GlobalScope.launch. Use delay(300) inside the coroutine. Import necessary coroutine libraries.

Kotlin

// Your code here to create a coroutine Job named job

Hint

Use GlobalScope.launch to start a coroutine and assign it to job. Use repeat(5) to print "Working..." five times with delay(300) between prints.

2

Add a variable to check job status

Add a variable named isJobActive that stores the job.isActive property after starting the job.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = GlobalScope.launch {
        repeat(5) {
            println("Working...")
            delay(300)
        }
    }
    job.join()
    // Add a variable isJobActive to store job.isActive
    
}

Hint

After launching the job, create val isJobActive = job.isActive to check if the job is running.

3

Cancel the job and check completion

Call job.cancel() to cancel the job. Then add a variable isJobCompleted that stores job.isCompleted.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = GlobalScope.launch {
        repeat(5) {
            println("Working...")
            delay(300)
        }
    }
    job.join()
    val isJobActive = job.isActive
    // Cancel the job
    // Add a variable isJobCompleted to store job.isCompleted
}

Hint

Use job.cancel() to stop the job and then check job.isCompleted to see if it finished.

4

Print job status after cancellation

Print the values of isJobActive and isJobCompleted using println statements.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = GlobalScope.launch {
        repeat(5) {
            println("Working...")
            delay(300)
        }
    }
    job.cancel()
    val isJobActive = job.isActive
    val isJobCompleted = job.isCompleted
    // Print isJobActive and isJobCompleted
}

Hint

Use println("Job active: $isJobActive") and println("Job completed: $isJobCompleted") to show the job status.

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