Why coroutines matter for async programming in Kotlin - See It in Action

Why coroutines matter for async programming

📖 Scenario: You are building a simple Kotlin program that fetches data from two sources asynchronously. You want to see how coroutines help make this easy and clear.

🎯 Goal: Learn how to use Kotlin coroutines to run two tasks at the same time and wait for both to finish before continuing.

📋 What You'll Learn

Create two suspend functions that simulate fetching data with delay

Use a coroutine scope to launch both tasks asynchronously

Wait for both tasks to complete and combine their results

Print the combined result

💡 Why This Matters

🌍 Real World

Coroutines help apps fetch data from the internet or do background work without freezing the screen.

💼 Career

Many Kotlin developers use coroutines to write clean, efficient asynchronous code in Android apps and backend services.

1

Create suspend functions to simulate data fetching

Write two suspend functions called fetchData1 and fetchData2. Each should delay for 1000 milliseconds and then return a string: "Data1" and "Data2" respectively.

Kotlin

# Write suspend functions fetchData1 and fetchData2 here

Hint

Use suspend fun to create functions that can pause. Use delay(1000L) to wait 1 second.

2

Set up main function with coroutine scope

Create a main function and inside it, use runBlocking to start a coroutine scope.

Kotlin

import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    // Your code here
}

Hint

Use fun main() = runBlocking { } to start your coroutine scope.

3

Launch both fetches asynchronously and wait for results

Inside runBlocking, use async to start fetchData1() and fetchData2() concurrently. Store their results in result1 and result2 by calling await() on each.

Kotlin

import kotlinx.coroutines.async

fun main() = runBlocking {
    val deferred1 = async { fetchData1() }
    val deferred2 = async { fetchData2() }
    // Your code here to await results
}

Hint

Use async { } to start tasks and await() to get their results.

4

Print the combined results

Print the combined string of result1 and result2 separated by a space using println.

Kotlin

fun main() = runBlocking {
    val deferred1 = async { fetchData1() }
    val deferred2 = async { fetchData2() }
    val result1 = deferred1.await()
    val result2 = deferred2.await()
    // Your code here to print results
}

Hint

Use println("$result1 $result2") to show the combined results.

Practice

1. Why are coroutines important for asynchronous programming in Kotlin?

easy

A. They allow tasks to run without blocking the main thread.

B. They make the code run slower but safer.

C. They replace all functions with loops.

D. They force the program to wait for each task to finish.

Solution

1. Step 1: Understand asynchronous programming

   Asynchronous programming means running tasks without stopping the main program flow.

2. Step 2: Role of coroutines in Kotlin

   Coroutines let tasks run in the background without blocking the main thread, improving responsiveness.

3. Final Answer:

   They allow tasks to run without blocking the main thread. -> Option A

4. Quick Check:

   Coroutines = non-blocking tasks [OK]

Hint: Coroutines keep the app responsive by not blocking main thread [OK]

Common Mistakes:

• Thinking coroutines slow down the program
• Confusing coroutines with loops
• Believing coroutines force waiting

2. Which of the following is the correct way to start a coroutine in Kotlin?

easy

A. startCoroutine { println("Hello") }

B. run { println("Hello") }

C. launch { println("Hello") }

D. beginCoroutine { println("Hello") }

Solution

1. Step 1: Recall coroutine builders in Kotlin

   The common builder to start a coroutine is launch.

2. Step 2: Check syntax correctness

   launch { ... } is valid, while others like startCoroutine or beginCoroutine are not standard coroutine starters.

3. Final Answer:

   launch { println("Hello") } -> Option C

4. Quick Check:

   Use launch to start coroutine [OK]

Hint: Remember: launch is the coroutine starter function [OK]

Common Mistakes:

• Using non-existent coroutine functions
• Confusing run with launch
• Trying to start coroutine without a builder

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

import kotlinx.coroutines.*
fun main() = runBlocking {
  launch {
    delay(100)
    println("World")
  }
  println("Hello")
}

medium

A. World\nHello

B. Hello\nWorld

C. Hello

D. World

Solution

1. Step 1: Understand runBlocking and launch

   runBlocking blocks main thread until all coroutines inside finish. launch starts a coroutine that delays 100ms before printing.

2. Step 2: Trace execution order

   "Hello" prints immediately. After 100ms delay, "World" prints. So output is "Hello" then "World".

3. Final Answer:

   Hello World -> Option B

4. Quick Check:

   Immediate print then delayed print = Hello then World [OK]

Hint: Immediate prints appear before delayed ones [OK]

Common Mistakes:

• Assuming launch blocks main thread
• Expecting World before Hello
• Ignoring delay effect

4. Identify the error in this Kotlin coroutine code:

fun main() {
  launch {
    println("Running")
  }
}

medium

A. launch requires a delay before printing.

B. println cannot be used inside launch.

C. main function must be suspend to use launch.

D. launch must be called inside a coroutine scope or suspend function.

Solution

1. Step 1: Check coroutine context requirements

   launch needs a coroutine scope or suspend function to run properly.

2. Step 2: Analyze main function usage

   Here, launch is called directly in main without a scope, causing an error.

3. Final Answer:

   launch must be called inside a coroutine scope or suspend function. -> Option D

4. Quick Check:

   launch needs coroutine scope [OK]

Hint: launch always needs a coroutine scope or suspend context [OK]

Common Mistakes:

• Thinking println is invalid inside launch
• Believing main must be suspend always
• Adding unnecessary delay

5. You want to fetch user data and user posts asynchronously in Kotlin using coroutines, then combine results. Which approach is best?

hard

A. Use async for both tasks and await their results before combining.

B. Use two separate launch blocks and combine results after both finish.

C. Run both tasks sequentially in the main thread.

D. Use delay to wait between fetching user data and posts.

Solution

1. Step 1: Understand async vs launch

   async returns a deferred result you can await; launch is for fire-and-forget tasks.

2. Step 2: Combining asynchronous results

   Using async for both tasks lets you start them concurrently and then await both results to combine efficiently.

3. Final Answer:

   Use async for both tasks and await their results before combining. -> Option A

4. Quick Check:

   async + await = concurrent results combined [OK]

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

Common Mistakes:

• Using launch when results are needed
• Running tasks sequentially wasting time
• Using delay instead of proper async control