async: cosa è, Deferred e come funzionano le coroutine parallele

Cos’è async in Kotlin Coroutines?

async — è una funzione di estensione di CoroutineScope che crea una coroutine restituendo un risultato. A differenza di launch, async restituisce Deferred<T> — un oggetto che rappresenta un valore futuro. Una coroutine avviata tramite async viene eseguita concorrentemente con altre coroutine, consentendo di parallelizzare i calcoli.

async viene utilizzato quando il risultato di un’operazione asincrona è necessario per l’elaborazione successiva: caricamento di dati da più fonti, elaborazione in batch di collezioni, richieste parallele a varie API. Deferred viene creato immediatamente e il risultato diventa disponibile dopo il completamento della coroutine.

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())
}

Sintassi di async e Deferred

La firma di async è simile a launch: gli stessi parametri CoroutineContext, CoroutineStart e un blocco suspend. La differenza sta nel tipo di ritorno — Deferred<T> invece di Job, dove T è il tipo di risultato restituito dall’ultima espressione del blocco.

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

Deferred<T> — un’interfaccia che eredita Job e aggiunge i metodi await(), getCompleted(), getCompletionExceptionOrNull(). await() è una funzione suspend e può essere chiamata solo all’interno di una coroutine o di un’altra funzione suspend. getCompleted() è un metodo non bloccante che lancia un’eccezione se la coroutine non è ancora stata completata.

Attività parallele con async

Il principale vantaggio di async è la capacità di eseguire attività in parallelo. Invece di attendere ogni operazione sequenzialmente (tempo totale = somma dei tempi), async avvia le coroutine simultaneamente, riducendo il tempo totale alla durata dell’operazione più lunga.

Caricamento parallelo dei dati

Uno scenario tipico — caricare il profilo utente, le sue impostazioni e la cronologia ordini con tre richieste async parallele. Dopo il completamento di tutte e tre, i risultati vengono combinati in un unico modello di dati.

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()
    )
}

La funzione coroutineScope avvia coroutine figlie e attende il loro completamento prima di restituire il risultato. L’intero blocco viene eseguito in parallelo, non sequenzialmente.

Gestione dei risultati Deferred

Deferred supporta diversi metodi per lavorare con il risultato. Oltre a await(), ci sono metodi per controllare lo stato, ottenere un valore completato e aggregare più Deferred tramite le funzioni di utilità di Kotlin Coroutines.

Per aggregare una lista di Deferred, si usa awaitAll() — una funzione che sospende l’esecuzione fino al completamento di tutti i Deferred nella collezione. Se almeno uno si è completato con errore, awaitAll() lancia l’eccezione.

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

Differenze tra async e launch

La scelta tra async e launch dipende dal fatto che il risultato della coroutine sia necessario. launch restituisce Job ed è adatto per operazioni fire-and-forget, async restituisce Deferred ed è usato per attività che restituiscono dati. In termini di sintassi e parametri, i costruttori sono identici.

• launch → Job (nessun risultato), async → Deferred<T> (risultato T)
• launch — attività fire-and-forget (logging, caching, invio analitiche)
• async — calcoli paralleli (caricamento da più API, elaborazione in batch)
• Entrambi supportano la concorrenza strutturata e i parametri CoroutineStart
• await() è disponibile solo per Deferred, launch non fornisce risultato

Regola importante: non usare mai async per fire-and-forget. Se il risultato della coroutine non è necessario, usa launch. async crea un overhead per la creazione di Deferred, che non è giustificato in tali scenari.

Esempi di async nello sviluppo mobile

In Android, async viene utilizzato per operazioni parallele all’interno di ViewModel e UseCases. Scenari tipici: caricare profilo e feed notizie simultaneamente, ottenere meteo da più servizi meteorologici, sincronizzazione batch dei dati con il 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 }
        }
    }
}

Si raccomanda di avvolgere un gruppo di async in coroutineScope o supervisorScope per isolare gli errori. supervisorScope consente alle restanti coroutine async di continuare anche se una fallisce — utile per operazioni non critiche.