launch and async builders in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when using launch in a CoroutineScope?

Consider this Kotlin code snippet inside an Android activity:

lifecycleScope.launch {
  delay(1000)
  textView.text = "Hello"
}

What will the user see immediately after this code runs?

Android Kotlin

lifecycleScope.launch {
  delay(1000)
  textView.text = "Hello"
}

A The textView updates to "Hello" after 1 second delay.

B The app crashes because delay cannot be used here.

C The textView updates immediately without delay.

D The textView never updates because launch does not run.

💡 Hint

launch starts a coroutine that runs asynchronously and can delay without blocking the main thread.

The launch builder starts a coroutine that runs asynchronously. The delay suspends the coroutine for 1 second without blocking the UI thread. After the delay, the textView text is updated.

🧠 Conceptual

intermediate

Difference between launch and async builders?

Which statement correctly describes the difference between launch and async coroutine builders in Kotlin?

A launch can only be used in background threads; async only on main thread.

B launch returns a Job and does not produce a result; async returns a Deferred and produces a result.

C launch blocks the thread; async runs asynchronously without blocking.

D launch returns a Deferred; async returns a Job.

💡 Hint

Think about which builder lets you get a result back.

launch starts a coroutine and returns a Job, which represents the coroutine but does not produce a result. async starts a coroutine and returns a Deferred, which is a future result you can await.

📝 Syntax

advanced

What is the output of this async coroutine code?

Given this Kotlin code snippet:

val deferred = lifecycleScope.async {
  delay(500)
  42
}

val result = runBlocking {
  deferred.await()
}
println(result)

What will be printed?

Android Kotlin

val deferred = lifecycleScope.async {
  delay(500)
  42
}

val result = runBlocking {
  deferred.await()
}
println(result)

A The code never prints because of deadlock.

B 0

C The code throws an exception because await is called outside coroutine.

D 42

💡 Hint

await waits for the async coroutine to finish and returns its result.

The async builder returns a Deferred that produces 42 after 500ms delay. runBlocking waits for deferred.await() to complete and returns 42, which is printed.

❓ lifecycle

advanced

What happens if you launch a coroutine in lifecycleScope after onDestroy?

In an Android activity, what happens if you call lifecycleScope.launch { /* some code */ } after the onDestroy() method has been called?

A The coroutine is immediately cancelled and does not run.

B The coroutine runs normally even after onDestroy.

C The app crashes with IllegalStateException.

D The coroutine runs but leaks memory.

💡 Hint

lifecycleScope is tied to the lifecycle and cancels coroutines when destroyed.

lifecycleScope is cancelled when the lifecycle owner is destroyed. Launching a coroutine after onDestroy means the scope is cancelled, so the coroutine is immediately cancelled and does not run.

🔧 Debug

expert

Why does this async coroutine code cause a deadlock?

Analyze this Kotlin code snippet:

val deferred = lifecycleScope.async {
  delay(1000)
  10
}

val result = deferred.await()
println(result)

Why might this code cause the app to freeze or deadlock?

Android Kotlin

val deferred = lifecycleScope.async {
  delay(1000)
  10
}

val result = deferred.await()
println(result)

A Because lifecycleScope.async returns null causing NullPointerException.

B Because delay cannot be used inside async builder.

C Because await is called on the main thread blocking it, preventing async from completing.

D Because println blocks the coroutine indefinitely.

💡 Hint

Consider what happens when you block the main thread waiting for a coroutine that also runs on the main thread.

Calling deferred.await() on the main thread blocks it. Since lifecycleScope.async runs on the main thread by default, the coroutine cannot resume to complete, causing a deadlock.

Practice

1. What is the main difference between launch and async builders in Kotlin coroutines?

easy

A. launch is used only for UI updates, async for background tasks.

B. launch blocks the main thread, async does not.

C. launch returns a value immediately, async never returns.

D. launch does not return a result, async returns a Deferred result.

Solution

1. Step 1: Understand launch behavior

   launch starts a coroutine that runs code asynchronously but does not return a value.

2. Step 2: Understand async behavior

   async starts a coroutine and returns a Deferred object, which you can await to get a result.

3. Final Answer:

   launch does not return a result, async returns a Deferred result. -> Option D

4. Quick Check:

   launch = no result, async = returns result [OK]

Hint: Remember: async returns a result, launch does not [OK]

Common Mistakes:

• Thinking launch returns a value
• Confusing async with blocking calls
• Assuming launch blocks the main thread

2. Which of the following is the correct syntax to start a coroutine with async in Kotlin?

easy

A. async.launch { fetchData() }

B. val result = launch { fetchData() }

C. val result = async { fetchData() }

D. launch.async { fetchData() }

Solution

1. Step 1: Identify correct coroutine builder usage

   async is called as a function returning a Deferred, so val result = async { fetchData() } is correct.

2. Step 2: Check other options for syntax errors

   launch does not return a value, so val result = launch { fetchData() } is wrong for async usage. Options C and D have invalid syntax.

3. Final Answer:

   val result = async { fetchData() } -> Option C

4. Quick Check:

   async returns Deferred, so assign it [OK]

Hint: async returns Deferred, assign it to a variable [OK]

Common Mistakes:

• Using launch instead of async when expecting a result
• Trying to chain async.launch or launch.async
• Not assigning async result to a variable

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

fun main() = runBlocking {
  val deferred = async {
    delay(100)
    10 + 20
  }
  println("Result: ${deferred.await()}")
}

medium

A. Result: 0

B. Result: 30

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand async and await behavior

   The async block runs asynchronously and returns a Deferred. Calling await() waits for the result.

2. Step 2: Calculate the expression inside async

   The code delays 100ms then returns 10 + 20 = 30, which is printed.

3. Final Answer:

   Result: 30 -> Option B

4. Quick Check:

   async + await returns computed value [OK]

Hint: await() gets async result after delay [OK]

Common Mistakes:

• Forgetting to call await() to get result
• Expecting immediate result without delay
• Confusing launch with async return

4. Identify the error in this Kotlin coroutine code:

fun main() = runBlocking {
  val result = launch {
    val data = fetchData()
  }
  println(data)
}

suspend fun fetchData(): String {
  delay(100)
  return "Hello"
}

medium

A. Variable 'data' is not accessible outside launch block

B. fetchData() cannot be called inside launch

C. runBlocking cannot be used with launch

D. Missing await() on launch

Solution

1. Step 1: Check variable scope of 'data'

   The variable 'data' is declared inside the launch coroutine block, so it is not visible outside.

2. Step 2: Analyze println(data) usage

   Trying to print 'data' outside launch causes a compilation error because 'data' is undefined there.

3. Final Answer:

   Variable 'data' is not accessible outside launch block -> Option A

4. Quick Check:

   Variables inside launch are local to its block [OK]

Hint: Variables inside launch are local; can't access outside [OK]

Common Mistakes:

• Assuming launch returns a value
• Trying to await launch (which returns Job)
• Ignoring variable scope rules

5. You want to fetch two independent data sources concurrently and combine their results. Which Kotlin coroutine approach is best?

val data1 = async { fetchData1() }
val data2 = async { fetchData2() }
val combined = data1.await() + data2.await()

Why is this approach preferred over launching two launch coroutines and combining results later?

hard

A. async returns Deferred results that can be awaited and combined immediately

B. launch blocks the main thread, async does not

C. launch cannot run multiple coroutines concurrently

D. async automatically caches results, launch does not

Solution

1. Step 1: Understand concurrency with async

   Using async starts coroutines that return Deferred results, allowing you to wait for and combine their outputs.

2. Step 2: Compare with launch behavior

   launch returns Job and does not provide a direct result, so combining outputs requires extra state management.

3. Final Answer:

   async returns Deferred results that can be awaited and combined immediately -> Option A

4. Quick Check:

   async = awaitable result, launch = no result [OK]

Hint: Use async to get results you can combine easily [OK]

Common Mistakes:

• Thinking launch returns a value
• Assuming launch blocks main thread
• Believing async caches results automatically