async: ce este, Deferred și corutine paralele cum funcționează

Ce este async în Kotlin Coroutines?

async — este o funcție de extensie CoroutineScope care creează o corutină cu returnare de rezultat. Spre deosebire de launch, async returnează Deferred<T> — un obiect care reprezintă o valoare viitoare. Corutina lansată prin async se execută concurent cu alte corutine, permițând paralelizarea calculelor.

async este utilizat când rezultatul operației asincrone este necesar pentru procesare ulterioară: încărcarea datelor din mai multe surse, procesarea în lot a colecțiilor, cereri paralele la diverse API-uri. Deferred este creat imediat, iar rezultatul devine disponibil după finalizarea corutinei.

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

Sintaxa async și Deferred

Semnătura async este similară cu launch: aceiași parametri CoroutineContext, CoroutineStart și bloc suspend. Diferența constă în tipul returnat — Deferred<T> în loc de Job, unde T este tipul rezultatului returnat de ultima expresie a blocului.

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

Deferred<T> — interfață care moștenește Job și adaugă metodele await(), getCompleted(), getCompletionExceptionOrNull(). await() este o funcție suspend și poate fi apelată doar în interiorul unei corutine sau altei funcții suspend. getCompleted() — metodă neblocantă care aruncă o excepție dacă corutina nu s-a încheiat încă.

Sarcini paralele cu async

Principalul avantaj al async este posibilitatea de a lansa sarcini în paralel. În loc de așteptarea secvențială a fiecărei operații (timp total = suma timpurilor), async lansează corutinele simultan, reducând timpul total la timpul celei mai lungi operații.

Încărcarea paralelă a datelor

Scenariu tipic — încărcarea profilului utilizatorului, setărilor și istoricului comenzilor prin trei cereri async paralele. După finalizarea tuturor celor trei, rezultatele sunt combinate într-un singur model de date.

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

Funcția coroutineScope lansează corutinele copil și așteaptă finalizarea lor înainte de a returna rezultatul. Întregul bloc se execută paralel, nu secvențial.

Procesarea rezultatelor Deferred

Deferred suportă mai multe metode pentru lucrul cu rezultatul. Pe lângă await(), sunt disponibile metode pentru verificarea stării, obținerea valorii gata și agregarea mai multor Deferred prin funcțiile utilitare Kotlin Coroutines.

Pentru agregarea unei liste de Deferred se folosește awaitAll() — o funcție care întrerupe execuția până la finalizarea tuturor Deferred din colecție. Dacă cel puțin unul s-a încheiat cu eroare, awaitAll() aruncă o excepție.

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

Diferențele dintre async și launch

Alegerea între async și launch depinde de necesitatea rezultatului execuției corutinei. launch returnează Job și este potrivit pentru operații fire-and-forget, async returnează Deferred și este folosit pentru sarcini care returnează date. Din punct de vedere al sintaxei și parametrilor, constructorii sunt identici.

• launch → Job (fără rezultat), async → Deferred<T> (are rezultat T)
• launch — sarcini fire-and-forget (logare, cache, trimitere analitică)
• async — calcule paralele (încărcare din mai multe API-uri, procesare în lot)
• Ambele suportă concurvența structurată și parametrii CoroutineStart
• await() este disponibil doar pentru Deferred, launch nu oferă rezultat

Regulă importantă: nu folosiți async pentru fire-and-forget. Dacă rezultatul corutinei nu este necesar, utilizați launch. async creează un overhead pentru crearea Deferred, care nu este justificat într-un astfel de scenariu.

Exemple async în dezvoltarea mobilă

În Android, async este utilizat pentru operații paralele în ViewModel și UseCases. Scenarii tipice: încărcarea simultană a profilului și a fluxului de știri, obținerea vremii de la mai multe servicii meteo, sincronizarea în lot a datelor cu serverul.

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

Se recomandă încapsularea grupului async în coroutineScope sau supervisorScope pentru izolarea erorilor. supervisorScope permite continuarea execuției celorlalte corutine async chiar și la eroare într-una dintre ele — util pentru operații necritice.