Async and await for concurrent results in Kotlin

Introduction

Async and await let your program do many things at the same time. This helps it run faster by not waiting for one task to finish before starting another.

When you want to download several files from the internet at once.

When you need to get data from multiple sources without waiting for each one in order.

When you want to run several calculations at the same time to save time.

When you want your app to stay responsive while doing slow tasks in the background.

Syntax

Kotlin

val deferred = async {
    // some long running task
}

val result = deferred.await()

async starts a task that runs in the background.

await waits for the task to finish and gets the result.

Examples

This runs a simple addition in the background and prints 10.

Kotlin

val deferred = async {
    5 + 5
}
val result = deferred.await()
println(result)

This runs two data fetches at the same time and waits for both results.

Kotlin

val deferred1 = async { fetchDataFromServer1() }
val deferred2 = async { fetchDataFromServer2() }

val result1 = deferred1.await()
val result2 = deferred2.await()
println("Results: $result1 and $result2")

Sample Program

This program starts two tasks that finish after different times. It waits for both to finish and then prints their results.

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred1 = async {
        delay(1000L) // pretend to do some work
        "First Result"
    }
    val deferred2 = async {
        delay(500L) // faster work
        "Second Result"
    }

    println("Waiting for results...")
    val result1 = deferred1.await()
    val result2 = deferred2.await()

    println("Got results:")
    println(result1)
    println(result2)
}

Important Notes

Use runBlocking in main to run suspend functions in a simple program.

Async tasks start immediately and run in parallel inside the coroutine scope.

Await pauses only the current coroutine until the result is ready, not the whole program.

Summary

Async starts a background task that runs at the same time as others.

Await waits for the background task to finish and gets its result.

Using async and await together helps your program do many things faster and stay responsive.

Practice

1. What does the async function do in Kotlin coroutines?

easy

A. Starts a background task that runs concurrently

B. Waits for a task to complete and returns its result

C. Blocks the main thread until a task finishes

D. Cancels a running coroutine immediately

Solution

1. Step 1: Understand the role of async

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

2. Step 2: Differentiate from await

   await waits for the result of the background task started by async, but async itself only starts the task.

3. Final Answer:

   Starts a background task that runs concurrently -> Option A

4. Quick Check:

   async = starts background task [OK]

Hint: Async starts tasks without waiting, await waits for results [OK]

Common Mistakes:

• Confusing async with await
• Thinking async blocks the main thread
• Assuming async cancels tasks

2. Which of the following is the correct syntax to start two concurrent tasks and wait for both results in Kotlin?

easy

A. val result1 = async { task1() }.await()
val result2 = async { task2() }.await()

B. val result1 = await(async { task1() })
val result2 = await(async { task2() })

C. val deferred1 = async { task1() }
val deferred2 = async { task2() }
val result1 = deferred1.await()
val result2 = deferred2.await()

D. val result1 = task1()
val result2 = task2()

Solution

1. Step 1: Identify correct async-await usage

   In Kotlin, async returns a Deferred object, which you then call await() on to get the result.

2. Step 2: Check syntax correctness

   val deferred1 = async { task1() } val deferred2 = async { task2() } val result1 = deferred1.await() val result2 = deferred2.await() correctly starts two async tasks and awaits their results separately, allowing concurrency.

3. Final Answer:

   val deferred1 = async { task1() } val deferred2 = async { task2() } val result1 = deferred1.await() val result2 = deferred2.await() -> Option C

4. Quick Check:

   async returns Deferred, await gets result [OK]

Hint: Store async in Deferred, then call await separately [OK]

Common Mistakes:

• Calling await immediately after async (no concurrency)
• Using await as a standalone function
• Not storing async result before await

3. What will be the output of the following Kotlin code?

import kotlinx.coroutines.*

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

medium

A. 10

B. 30

C. 20

D. Compilation error

Solution

1. Step 1: Understand async and delay behavior

   Two async tasks run concurrently: one delays 100ms and returns 10, the other delays 50ms and returns 20.

2. Step 2: Await both results and sum

   Awaiting both deferreds gets 10 and 20, summing to 30, printed as output.

3. Final Answer:

   30 -> Option B

4. Quick Check:

   10 + 20 = 30 [OK]

Hint: Sum awaited results after async tasks complete [OK]

Common Mistakes:

• Assuming sequential execution ignoring concurrency
• Confusing delay times with output values
• Expecting compilation errors due to coroutines

4. Identify the error in this Kotlin coroutine code snippet:

fun main() = runBlocking {
    val result = async {
        delay(100)
        42
    }.await()
    println(result)
}

medium

A. Calling await() immediately after async() blocks concurrency

B. Missing coroutine scope for async

C. delay() cannot be used inside async

D. runBlocking cannot be used in main function

Solution

1. Step 1: Analyze async and await usage

   Calling await() immediately after async waits for the task to finish before continuing, so concurrency is lost.

2. Step 2: Understand concurrency impact

   This pattern runs the async task sequentially, blocking until completion, defeating the purpose of async concurrency.

3. Final Answer:

   Calling await() immediately after async() blocks concurrency -> Option A

4. Quick Check:

   Immediate await blocks concurrency [OK]

Hint: Don't await right after async; store Deferred first [OK]

Common Mistakes:

• Thinking immediate await keeps concurrency
• Believing delay is disallowed inside async
• Assuming runBlocking can't be main

5. You want to fetch data from two APIs concurrently and combine their results in Kotlin. Which approach best uses async and await for this task?

hard

A. Call the first API synchronously, then start async for the second API and await it

B. Run both API calls sequentially inside async blocks without await

C. Use await without async for both API calls to simplify code

D. Start two async coroutines for each API call, then await both results before combining

Solution

1. Step 1: Understand concurrency for API calls

   Starting both API calls concurrently with async allows them to run at the same time, saving time.

2. Step 2: Await both results before combining

   Using await on both deferred results ensures you get both responses before combining them safely.

3. Final Answer:

   Start two async coroutines for each API call, then await both results before combining -> Option D

4. Quick Check:

   Async start + await both = concurrent fetch [OK]

Hint: Async both calls, await both results, then combine [OK]

Common Mistakes:

• Running API calls sequentially losing concurrency
• Using await without async causing errors
• Not awaiting results before combining