Come eseguire il codice in un thread parallelo (non…

Per l'esecuzione parallela del codice su Android, vengono utilizzati diversi meccanismi che consentono di non bloccare il thread principale (UI) e di mantenere la reattività dell'app.

Mezzi integrati di Android:

Thread: Classe base per creare un nuovo thread.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Codice da eseguire nel thread parallelo
    }
}).start();

Svantaggio: La gestione manuale dei thread può causare problemi con il ciclo di vita e perdite di memoria.

AsyncTask (Obsoleto): Facilitava il lavoro con thread paralleli e l'interazione con il thread UI.

private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        // Codice da eseguire in background
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        // Lavoro con il thread UI dopo doInBackground
    }
}
// Uso: new MyAsyncTask().execute();

Svantaggi: Obsoleto, ha limitazioni e difficoltà nella gestione del ciclo di vita.

Handler e Looper: Permettono di creare thread con loop di elaborazione dei messaggi.

HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        // Codice da eseguire nel thread con Looper
    }
});

Vantaggio: Utile per compiti ripetitivi o gestione di eventi asincroni in un thread separato.

ExecutorService / ThreadPoolExecutor: Forniscono pool di thread, più efficienti rispetto alla creazione di un nuovo Thread per ogni task.

ExecutorService executor = Executors.newSingleThreadExecutor(); // O newCachedThreadPool(), newFixedThreadPool(N)
executor.execute(new Runnable() {
    @Override
    public void run() {
        // Codice da eseguire nel thread del pool
    }
});
// Non dimenticare di chiamare executor.shutdown() al termine

Vantaggi: Gestiscono la creazione e il riutilizzo dei thread, riducendo i costi.

Approcci moderni:

Kotlin Coroutines: Thread leggeri che offrono un modo più semplice e leggibile di programmazione asincrona.

import kotlinx.coroutines.*

// Avviare una coroutine in un pool di thread (simile a un thread di background)
GlobalScope.launch(Dispatchers.Default) {
    // Codice da eseguire in background
}

// Avviare una coroutine per operazioni di IO
GlobalScope.launch(Dispatchers.IO) {
    // Codice per operazioni di IO (rete, file, ecc.)
}

// Passare al thread UI per aggiornare l'interfaccia utente
GlobalScope.launch(Dispatchers.Default) {
    // Calcoli in background
    withContext(Dispatchers.Main) {
        // Aggiornamento UI
    }
}

Vantaggi: Migliore leggibilità del codice, uso più efficiente delle risorse, gestione semplice dell'annullamento delle attività, concorrenza strutturata.

RxJava / RxKotlin: Programmazione reattiva basata su flussi di dati osservabili.

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

Observable.just("Un risultato")
    .subscribeOn(Schedulers.io()) // Eseguire nel thread IO
    .observeOn(AndroidSchedulers.mainThread()) // Osservare nel thread UI
    .subscribe(/* Gestione risultato */);

Vantaggi: Strumento potente per eventi asincroni e trasformazione dei dati, ma con una curva di apprendimento più ripida.

Libreria WorkManager:

WorkManager: Componente raccomandato di Architecture Components per garantire l'esecuzione affidabile di attività in background, anche se l'applicazione è chiusa o il dispositivo viene riavviato.

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

class MyWorker(appContext: Context, workerParams: WorkerParameters): Worker(appContext, workerParams) {
    override fun doWork(): Result {
        // Codice da eseguire in background
        return Result.success() // O Result.failure(), Result.retry()
    }
}

// Creare una richiesta per eseguire il task
val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Restrizioni opzionali
    .build()

// Inserire il task in coda
WorkManager.getInstance(context).enqueue(workRequest)

Vantaggi: Esecuzione garantita, supporto a restrizioni (tipo di rete, batteria), gestione di cancellazioni, esecuzione differita e ripetizioni.

La scelta del metodo specifico per eseguire codice in un thread parallelo dipende dal tipo di task, dal ciclo di vita e dai requisiti di affidabilità. Per la maggior parte delle applicazioni Android moderne, si consiglia di utilizzare Kotlin Coroutines o WorkManager.

Come eseguire il codice in un thread parallelo (non principale)?