Cum porniți operațiile asincrone în Android pur…

Se pot folosi mai multe metode:

Thread: Crearea unui nou fir pentru executarea unei sarcini. Simplu, dar gestionarea ciclului de viață și transmiterea datelor înapoi către firul principal necesită logică suplimentară (Handler, runOnUiThread).

new Thread(new Runnable() {
    @Override
    public void run() {
        // Executarea unei operații asincrone
        // Actualizarea UI-ului prin runOnUiThread sau Handler
    }
}).start();

AsyncTask: Învechit, dar o clasă simplă pentru executarea operațiilor în fundal și actualizarea UI-ului. Oferă metode onPreExecute, doInBackground, onProgressUpdate, onPostExecute.

private static class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Executarea unei operații asincrone
        return "Rezultat";
    }

    @Override
    protected void onPostExecute(String result) {
        // Actualizarea UI-ului în firul principal
    }
}

// Pornire: new MyAsyncTask().execute();

Handler și Looper: mecanism mai flexibil pentru trimiterea și procesarea mesajelor și sarcinilor între fire. Handler este asociat cu Looper al firului în care a fost creat.

Handler handler = new Handler(Looper.getMainLooper()); // Pentru firul principal

handler.post(new Runnable() {
    @Override
    public void run() {
        // Executarea sarcinii în firul principal după operația asincronă
    }
});

ExecutorService și Callable/Runnable: mecanisme standard Java pentru gestionarea unui pool de fire. Permite utilizarea mai eficientă a resurselor și gestionarea execuției mai multor sarcini.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Sau alt tip de executor

executor.submit(new Runnable() {
    @Override
    public void run() {
        // Executarea unei operații asincrone
    }
});

// Sau submit(Callable) pentru obținerea unui rezultat

Coroutine (cu Kotlin): mod mai modern și mai convenabil de a gestiona operațiuni asincrone în Kotlin. Permite scrierea codului asincron în stil imperativ. Necesită adăugarea dependențelor corespunzătoare.

import kotlinx.coroutines.*

GlobalScope.launch(Dispatchers.IO) {
    // Executarea unei operații asincrone în fir de fundal
    withContext(Dispatchers.Main) {
        // Actualizarea UI-ului în firul principal
    }
}

Cum porniți operațiile asincrone în Android pur?