Async coroutine builder in Kotlin - Mini Project: Build & Apply

Async coroutine builder

📖 Scenario: You are building a simple Kotlin program that uses asynchronous coroutines to fetch data without blocking the main thread. This is like ordering food at a restaurant and waiting for it to be prepared while you relax, instead of standing at the counter waiting.

🎯 Goal: Create a Kotlin program that uses the async coroutine builder to start a background task that returns a result, then waits for the result and prints it.

📋 What You'll Learn

Create a coroutine scope using runBlocking

Use the async builder to start a coroutine that returns a string

Use await() to get the result from the async coroutine

Print the result to the console

💡 Why This Matters

🌍 Real World

Async coroutines let programs do work in the background without freezing the app, like loading images or fetching data while you keep using the app.

💼 Career

Understanding async coroutines is important for Kotlin developers working on Android apps or backend services to write efficient, responsive code.

1

Setup coroutine scope

Write a Kotlin program that starts with fun main() and inside it, create a coroutine scope using runBlocking.

Kotlin

fun main() {
    // Create a coroutine scope using runBlocking
    // Your code here
}

Hint

Use runBlocking { } inside main to create a coroutine scope.

2

Start async coroutine

Inside the runBlocking block, create a variable called deferred and assign it to an async coroutine that returns the string "Hello from async".

Kotlin

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.async

fun main() {
    runBlocking {
        // Create async coroutine that returns "Hello from async"
        // Your code here
    }
}

Hint

Use val deferred = async { "Hello from async" } inside runBlocking.

3

Await async result

Use await() on the deferred variable to get the result and store it in a variable called result.

Kotlin

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.async

fun main() {
    runBlocking {
        val deferred = async {
            "Hello from async"
        }
        // Await the result from deferred
        // Your code here
    }
}

Hint

Use val result = deferred.await() to get the async result.

4

Print the result

Print the result variable using println inside the runBlocking block.

Kotlin

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.async

fun main() {
    runBlocking {
        val deferred = async {
            "Hello from async"
        }
        val result = deferred.await()
        // Print the result
        // Your code here
    }
}

Hint

Use println(result) to display the message.

Practice

1. What does the async coroutine builder do in Kotlin?

easy

A. Starts a background task and returns a Deferred result

B. Blocks the main thread until the task finishes

C. Runs code only on the main thread

D. Creates a new thread without coroutine support

Solution

1. Step 1: Understand async behavior

   The async builder starts a coroutine that runs in the background without blocking the main thread.

2. Step 2: Recognize the return type

   It returns a Deferred object which holds the future result of the background task.

3. Final Answer:

   Starts a background task and returns a Deferred result -> Option A

4. Quick Check:

   async = background task + Deferred [OK]

Hint: async always returns Deferred for background work [OK]

Common Mistakes:

• Thinking async blocks the main thread
• Confusing async with launch which returns Job
• Assuming async runs only on main thread

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

easy

A. val result = async(compute())

B. val result = async { compute() }

C. val result = async.compute()

D. val result = async -> compute()

Solution

1. Step 1: Identify correct async syntax

   The async builder is called with a lambda block: async { ... }.

2. Step 2: Check each option

   val result = async { compute() } correctly uses async { compute() }. Options B, C, and D misuse parentheses or operators.

3. Final Answer:

   val result = async { compute() } -> Option B

4. Quick Check:

   async uses curly braces for lambda [OK]

Hint: async always uses curly braces for its block [OK]

Common Mistakes:

• Using parentheses instead of curly braces
• Trying to call async like a function with dot notation
• Using arrow syntax incorrectly

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

import kotlinx.coroutines.*

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

medium

A. Result: null

B. Result: Deferred@someHashCode

C. Result: 42

D. Compilation error

Solution

1. Step 1: Understand async and await

   The async block runs a coroutine that delays 100ms then returns 42. The await() waits for this result.

2. Step 2: Print the awaited result

   The println prints "Result: " plus the awaited value 42.

3. Final Answer:

   Result: 42 -> Option C

4. Quick Check:

   await() returns 42 after delay [OK]

Hint: await() gets the actual result from Deferred [OK]

Common Mistakes:

• Printing Deferred object instead of awaited value
• Forgetting to call await()
• Expecting immediate result without delay

4. Identify the error in this Kotlin coroutine code:

fun main() = runBlocking {
    val deferred = async {
        delay(100)
        10 / 0
    }
    println(deferred.await())
}

medium

A. Division by zero causes ArithmeticException at await()

B. async cannot be used inside runBlocking

C. Missing launch builder for coroutine

D. delay() cannot be called inside async

Solution

1. Step 1: Analyze the async block

   The async block performs 10 / 0, which causes a division by zero error.

2. Step 2: Understand exception propagation

   The exception is thrown when await() is called, as it waits for the async result.

3. Final Answer:

   Division by zero causes ArithmeticException at await() -> Option A

4. Quick Check:

   Exceptions in async appear on await() [OK]

Hint: Errors inside async show up when calling await() [OK]

Common Mistakes:

• Thinking async can't be inside runBlocking
• Assuming delay() is invalid in async
• Ignoring exceptions thrown inside async block

5. You want to run two independent background tasks concurrently and get their sum. Which Kotlin code correctly uses async to achieve this?

fun main() = runBlocking {
    val deferred1 = async { 10 }
    val deferred2 = async { 20 }
    val sum = ???
    println(sum)
}

hard

A. val sum = deferred1.get() + deferred2.get()

B. val sum = deferred1 + deferred2

C. val sum = await(deferred1) + await(deferred2)

D. val sum = deferred1.await() + deferred2.await()

Solution

1. Step 1: Understand how to get results from Deferred

   Each async returns a Deferred. To get the actual value, call await() on each.

2. Step 2: Sum the awaited results

   Use deferred1.await() + deferred2.await() to get the sum of both results.

3. Final Answer:

   val sum = deferred1.await() + deferred2.await() -> Option D

4. Quick Check:

   Sum = await both Deferreds [OK]

Hint: Use await() on Deferred to get values before summing [OK]

Common Mistakes:

• Trying to add Deferred objects directly
• Using non-existent get() method
• Calling await() as a standalone function