Milyen módszerekkel valósul meg a feladatok párhuzamos végrehajtása a modern rendszerekben?

A modern rendszerekben a feladatok párhuzamos végrehajtása többféleképpen valósítható meg:

1. Többszálúság (Threads) — több szál létrehozása és kezelése egy folyamaton belül. Androidon ez lehet a Thread osztály vagy az ExecutorService.

2. Aszinkron programozás — callback-ek, Future, CompletableFuture, Kotlin Coroutines használata a feladatok végrehajtásához anélkül, hogy blokkolnánk a fő szálat.

3. Szálmedencék (Thread Pools) — korlátozott számú szál kezelése a hatékony erőforrás-elosztás érdekében.

4. RxJava / Reaktív programozás — reaktív megközelítés az aszinkron adatfolyamok feldolgozására.

5. WorkManager / JobScheduler — rendszer API-k a háttérfeladatok ütemezéséhez, amelyek párhuzamosan futtathatók, figyelembe véve az eszköz korlátait.

Példa a Kotlin Coroutines használatára két feladat párhuzamos végrehajtására:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job1 = async { heavyTask() }
    val job2 = async { simpleTask() }

    println("Eredmények: ${job1.await()}, ${job2.await()}")
}

suspend fun heavyTask(): String {
    delay(1000) // nehéz munka szimulálása
    return "Nehéz feladat befejeződött"
}

suspend fun simpleTask(): String {
    delay(500) // egyszerű munka szimulálása
    return "Egyszerű feladat befejeződött"
}

Ez a megközelítés lehetővé teszi az erőforrások hatékony kihasználását és az UI blokkolásának elkerülését.