Async and await for concurrent results in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin coroutine code?

Consider this Kotlin code using async and await to run two tasks concurrently. What will be printed?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred1 = async {
        delay(100)
        "Hello"
    }
    val deferred2 = async {
        delay(50)
        "World"
    }
    println(deferred1.await() + " " + deferred2.await())
}

A HelloHello

B World Hello

C Hello World

D WorldWorld

💡 Hint

Remember that async starts both tasks immediately, but await waits for the result.

Both tasks start concurrently. deferred1 delays 100ms, deferred2 delays 50ms. However, deferred1.await() is called first, so the program waits for it to finish before calling deferred2.await(). The output is "Hello World".

❓ Predict Output

intermediate

What is the output when awaiting multiple async tasks?

What will this Kotlin program print?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferreds = (1..3).map { n ->
        async {
            delay(10L * n)
            n * n
        }
    }
    val results = deferreds.awaitAll()
    println(results.sum())
}

A 9

B 0

C 6

D 14

💡 Hint

Think about the squares of 1, 2, and 3 and their sum.

The tasks compute 1*1=1, 2*2=4, and 3*3=9. Their sum is 1+4+9=14.

🔧 Debug

advanced

Which option causes a runtime exception in this coroutine code?

Given this Kotlin coroutine snippet, which option will cause a runtime exception when run?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred = async {
        throw IllegalStateException("Error in coroutine")
    }
    try {
        deferred.await()
    } catch (e: Exception) {
        println("Caught: ${e.message}")
    }
}

A Remove the try-catch block around deferred.await()

B Call deferred.cancel() before await

C Add a delay before deferred.await()

D Replace async with launch

💡 Hint

Think about what happens if exceptions inside async are not caught.

Removing the try-catch means the exception thrown inside async is not caught, causing the program to crash with an IllegalStateException.

🧠 Conceptual

advanced

What is the main benefit of using async and await in Kotlin coroutines?

Choose the best explanation for why async and await are used in Kotlin coroutines.

A They automatically parallelize code on multiple CPU cores without programmer control.

B They allow running multiple tasks concurrently and waiting for their results without blocking the main thread.

C They replace all uses of threads and locks in Kotlin programs.

D They guarantee tasks run in a specific order sequentially.

💡 Hint

Think about concurrency and non-blocking waits.

async starts a coroutine that runs concurrently, and await suspends until the result is ready, all without blocking the main thread.

📝 Syntax

expert

Which option correctly uses async and await to fetch two results concurrently?

Which Kotlin code snippet correctly fetches two values concurrently using async and await and prints their sum?

A

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred1 = async { 10 }
    val deferred2 = async { 20 }
    println(deferred1.await() + deferred2.await())
}

B

val result = async { 10 } + async { 20 }
println(result)

C

val deferred1 = async { 10 }
val deferred2 = async { 20 }
println(deferred1 + deferred2)

D

val result1 = async { 10 }.await()
val result2 = async { 20 }.await()
println(result1 + result2)

💡 Hint

Remember that async returns a Deferred, and you must call await() to get the value.

Option A correctly starts two async coroutines and awaits their results before summing. Option A tries to add Deferred objects directly, causing a type error. Option A adds Deferred objects without awaiting, causing a type error. Option A awaits immediately, so the coroutines run sequentially, not concurrently.