async: What It Is, Deferred and Parallel Coroutines How They Work

What is async in Kotlin Coroutines?

async — is a CoroutineScope extension function that creates a coroutine returning a result. Unlike launch, async returns Deferred<T> — an object representing a future value. A coroutine launched via async executes concurrently with other coroutines, allowing computations to be parallelized.

async is used when the result of an asynchronous operation is needed for further processing: loading data from multiple sources, batch processing collections, parallel requests to various APIs. Deferred is created immediately, and the result becomes available after the coroutine completes.

import kotlinx.coroutines.*

suspend fun String.delayedValue(): String {
    delay(1000L)
    return this
}

fun main() = runBlocking {
    val deferred: Deferred<String> = async { "Hello".delayedValue() }
    println(deferred.await())
}

async and Deferred Syntax

The async signature is similar to launch: the same CoroutineContext, CoroutineStart parameters, and a suspend block. The difference is in the return type — Deferred<T> instead of Job, where T is the result type returned by the last expression of the block.

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

Deferred<T> — an interface inheriting Job and adding await(), getCompleted(), getCompletionExceptionOrNull() methods. await() is a suspend function and can only be called inside a coroutine or another suspend function. getCompleted() is a non-blocking method that throws an exception if the coroutine has not yet completed.

Parallel Tasks with async

The main advantage of async is the ability to run tasks in parallel. Instead of waiting for each operation sequentially (total time = sum of times), async launches coroutines simultaneously, reducing total time to the duration of the longest operation.

Parallel Data Loading

A typical scenario — loading a user profile, their settings, and order history with three parallel async requests. After all three complete, the results are combined into a single data model.

suspend fun loadUserDashboard(userId: String): Dashboard = coroutineScope {
    val profile = async { api.getProfile(userId) }
    val settings = async { api.getSettings(userId) }
    val orders = async { api.getRecentOrders(userId) }

    Dashboard(
        profile = profile.await(),
        settings = settings.await(),
        orders = orders.await()
    )
}

The coroutineScope function launches child coroutines and waits for their completion before returning the result. The entire block executes in parallel, not sequentially.

Handling Deferred Results

Deferred supports several methods for working with the result. In addition to await(), there are methods for checking status, getting a completed value, and aggregating multiple Deferreds through Kotlin Coroutines utility functions.

For aggregating a list of Deferreds, awaitAll() is used — a function that suspends execution until all Deferreds in the collection complete. If at least one completed with an error, awaitAll() throws the exception.

suspend fun <T> loadAll(requests: List<suspend () -> T>): List<T> {
    return coroutineScope {
        val deferreds = requests.map { async { it() } }
        deferreds.awaitAll()
    }
}

async vs launch Differences

The choice between async and launch depends on whether the coroutine result is needed. launch returns Job and is suitable for fire-and-forget operations, async returns Deferred and is used for tasks that return data. In terms of syntax and parameters, the builders are identical.

• launch → Job (no result), async → Deferred<T> (result T)
• launch — fire-and-forget tasks (logging, caching, sending analytics)
• async — parallel computations (loading from multiple APIs, batch processing)
• Both support structured concurrency and CoroutineStart parameters
• await() is only available for Deferred, launch does not provide a result

Important rule: never use async for fire-and-forget. If the coroutine result is not needed, use launch. async creates overhead for creating Deferred, which is not justified in such scenarios.

async Examples in Mobile Development

In Android, async is used for parallel operations inside ViewModel and UseCases. Typical scenarios: loading profile and news feed simultaneously, fetching weather from multiple weather services, batch data synchronization with the server.

class HomeViewModel : ViewModel() {
    fun loadHomeScreen() {
        viewModelScope.launch {
            val userData = async(Dispatchers.IO) { repository.getUserData() }
            val newsFeed = async(Dispatchers.IO) { repository.getNewsFeed() }
            val notifications = async(Dispatchers.IO) { repository.getNotifications() }

            val state = HomeState(
                user = userData.await(),
                news = newsFeed.await(),
                unread = notifications.await()
            )
            _uiState.update { state }
        }
    }
}

It is recommended to wrap a group of async calls in coroutineScope or supervisorScope for error isolation. supervisorScope allows the remaining async coroutines to continue even if one fails — useful for non-critical operations.