Hogyan futtassuk a kódot párhuzamos (nem fő) szálon…

Az Androidban a kód párhuzamos végrehajtásához különböző mechanizmusokat használnak, amelyek megakadályozzák a fő (UI) szál blokkolását, és megőrzik az alkalmazás válaszkészségét.

Az Android alapvető eszközei:

Thread: Egy új szál létrehozásának alap osztálya.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Kód párhuzamos szálon való végrehajtáshoz
    }
}).start();

Hátrány: A szálak kézi kezelése problémákhoz vezethet az életciklusban és memória szivárgásokhoz.

AsyncTask (Elavult): Egyszerűsíti a párhuzamos szálak kezelését és a UI szállal való interakciót.

private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        // Kód háttérben való végrehajtáshoz
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        // Munka a UI szállal a doInBackground befejezése után
    }
}
// Használat: new MyAsyncTask().execute();

Hátrányok: Elavult, korlátozásokkal és életciklus kezelési nehézségekkel jár.

Handler és Looper: Lehetővé teszik üzenetfeldolgozó ciklusokkal rendelkező szálak létrehozását.

HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        // Kód a Looper-rel rendelkező szálon való végrehajtáshoz
    }
});

Előny: Hasznos ismétlődő feladatok vagy aszinkron események feldolgozására külön szálon.

ExecutorService / ThreadPoolExecutor: Szálmedencék biztosítása, hatékonyabb, mint minden feladathoz új Thread létrehozása.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Vagy newCachedThreadPool(), newFixedThreadPool(N)
executor.execute(new Runnable() {
    @Override
    public void run() {
        // Kód a medencéből származó szálon való végrehajtáshoz
    }
});
// Ne felejtsd el meghívni az executor.shutdown() -t a végén

Előnyök: Kezeli a szálak létrehozását és újrahasznosítását, csökkenti a költségeket.

Modern megközelítések:

Kotlin Coroutines: Könnyű szálak, amelyek egyszerűbb és olvashatóbb módot kínálnak az aszinkron programozáshoz.

import kotlinx.coroutines.*

// Korutina indítása szálmedencében (hasonló a háttérszálhoz)
GlobalScope.launch(Dispatchers.Default) {
    // Kód végrehajtása a háttérben
}

// Korutina indítása IO műveletekhez
GlobalScope.launch(Dispatchers.IO) {
    // Kód IO műveletekhez (hálózat, fájlok stb.)
}

// Váltás UI szálra a felhasználói felület frissítéséhez
GlobalScope.launch(Dispatchers.Default) {
    // Háttér számítások
    withContext(Dispatchers.Main) {
        // UI frissítés
    }
}

Előnyök: Kód olvashatóságának javítása, hatékonyabb erőforrás-használat, egyszerű feladatmegszakítási kezelés, strukturált konkurencia.

RxJava / RxKotlin: Reaktív programozás, megfigyelhető adatfolyamokra alapozva.

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.schedulers.Schedulers;

Observable.just("Egy eredmény")
    .subscribeOn(Schedulers.io()) // Végrehajtás IO szálon
    .observeOn(AndroidSchedulers.mainThread()) // Megfigyelés UI szálon
    .subscribe(/* Eredmény feldolgozása */);

Előnyök: Erőteljes eszköz az aszinkron események kezelésére és az adatok átalakítására, de magasabb belépési küszöbbel rendelkezik.

WorkManager könyvtár:

WorkManager: Ajánlott komponens az Architecture Components-ből, garantált háttérfeladat végrehajtására, még akkor is, ha az alkalmazás bezáródik vagy az eszköz újraindul.

import androidx.work.*
import java.util.concurrent.TimeUnit

class MyWorker: Worker(appContext, workerParams) {
    override fun doWork(): Result {
        // Kód a háttérfeladat végrehajtásához
        return Result.success() // vagy Result.failure(), Result.retry()
    }
}

// Feladat kérés létrehozása
val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Opcionális korlátozások
    .build()

// Feladat sorba helyezése
WorkManager.getInstance(context).enqueue(workRequest)

Előnyök: Garantált végrehajtás, korlátozások támogatása (hálózattípus, akkumulátor töltöttsége), törlés kezelése, késleltetett végrehajtás és ismétlések.

A konkrét végrehajtási módszer kiválasztása a feladat típusától, életciklusától és megbízhatósági követelményektől függ. A modern Android alkalmazások többségéhez ajánlott a Kotlin Coroutines vagy a WorkManager használata.

Hogyan futtassuk a kódot párhuzamos (nem fő) szálon?