Hogyan dolgozik aszinkron műveletekkel?

A következő mechanizmusokat használom:

• Kotlin Coroutines: Strukturált konkurencia preferált módja. Lehetővé teszi az aszinkron kód írását imperatív stílusban.
  • launch: Új coroutine indítása háttérben.
  • async/await: Aszinkron művelet végrehajtása és eredmény (Deferred) visszaadása.
  • Kontextusok (Dispatchers): A coroutine végrehajtásához használt szálcsoportok (Main, IO, Default).
  • Strukturált konkurencia: A láthatósági területek (CoroutineScope) automatikusan megszakítják az alcoroutine-kat a szülő megszakításakor.
• RxJava (Reaktív kiterjesztések Java-hoz): Aszinkron adatfolyamok kezelése.
  • Observable/Flowable: Elemsorozat kibocsátása.
  • Operátorok (map, filter, flatMap stb.): Átalakítás és összefűzés.
  • Ütemezők (Schedulers): A műveletek végrehajtásához használt szálak meghatározása.
• Callbacks: Egyszerű mechanizmus a művelet befejezésekor történő visszahívásra. Bonyolult logikában "Callback Hell"-hez vezethet.
• AsyncTask (elavult): Hosszú műveletek végrehajtása háttérben és UI frissítése a fő szálon. Új projektekben nem ajánlott.
• Threads (Java szálak): Alacsony szintű szálkezelő mechanizmus. Kézi életciklus-kezelést és szinkronizációt igényel.

Korutinok használatának példája:

// Aszinkron művelet indítása IO-szálon és UI frissítése a Main szálon
lifecycleScope.launch(Dispatchers.IO) {
    val data = fetchDataFromNetwork() // Hosszú művelet
    withContext(Dispatchers.Main) {
        updateUI(data) // UI frissítése
    }
}

RxJava példája:

// Adatok lekérése a hálózatról és eredmény feldolgozása
Observable.fromCallable(() -> fetchDataFromNetwork())
    .subscribeOn(Schedulers.io()) // Végrehajtás IO-szálon
    .observeOn(AndroidSchedulers.mainThread()) // Eredmény a fő szálon
    .subscribe(data -> updateUI(data), error -> handleError(error));

A mechanizmus kiválasztása a feladattól függ: általános aszinkron programozáshoz korutinok, adatfolyamok kezeléséhez RxJava, egyszerű esetekhez callback-ek.