Cum se execută codul într-un thread paralel (nu…

Pentru executarea paralelă a codului în Android, se utilizează diferite mecanisme care evită blocarea thread-ului principal (UI) și păstrează receptivitatea aplicației.

Resursele standard ale Android:

Thread: Clasa de bază pentru crearea unui nou thread.
```
new Thread(new Runnable() {
    @Override
    public void run() {
        // Cod pentru execuție în thread paralel
    }
}).start();
```
Dezavantaj: Gestionarea manuală a thread-urilor poate duce la probleme cu ciclul de viață și scurgeri de memorie.

AsyncTask (Depășit): Simplifica gestionarea thread-urilor paralele și interacțiunea cu thread-ul UI.

private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        // Cod pentru execuție în fundal
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        // Lucru cu thread-ul UI după finalizarea doInBackground
    }
}
// Utilizare: new MyAsyncTask().execute();

Dezavantaje: Învechit, are limitări și dificultăți în gestionarea ciclului de viață.

Handler și Looper: Permite crearea de thread-uri cu bucle de procesare a mesajelor.

HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        // Cod pentru execuție în thread cu Looper
    }
});

Avantaj: Convenabil pentru executarea sarcinilor repetitive sau procesarea evenimentelor asincrone într-un thread separat.

ExecutorService / ThreadPoolExecutor: Oferă pool-uri de thread-uri, mai eficient decât crearea unui nou Thread pentru fiecare sarcină.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Sau newCachedThreadPool(), newFixedThreadPool(N)
executor.execute(new Runnable() {
    @Override
    public void run() {
        // Cod pentru execuție în thread-ul din pool
    }
});
// Nu uitați să apelați executor.shutdown() la finalizare

Avantaje: Gestionează crearea și reutilizarea thread-urilor, reducând costurile.

Abordări moderne:

Kotlin Coroutines: Thread-uri ușoare, oferind o modalitate mai simplă și mai lizibilă pentru programarea asincronă.

import kotlinx.coroutines.*

// Pornirea unei corutine într-un pool de thread-uri (analog cu thread-ul de fundal)
GlobalScope.launch(Dispatchers.Default) {
    // Cod pentru execuție în fundal
}

// Pornirea unei corutine pentru operații IO
GlobalScope.launch(Dispatchers.IO) {
    // Cod pentru operații IO (rețea, fișiere etc.)
}

// Comutarea pe thread-ul UI pentru actualizarea interfeței
GlobalScope.launch(Dispatchers.Default) {
    // Calcul în fundal
    withContext(Dispatchers.Main) {
        // Actualizare UI
    }
}

Avantaje: Claritatea codului îmbunătățită, utilizarea mai eficientă a resurselor, gestionare simplă a anulării sarcinilor, concurență structurată.

RxJava / RxKotlin: Programare reactivă bazată pe fluxuri de date observabile.

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

Observable.just("Un rezultat")
    .subscribeOn(Schedulers.io()) // Execută pe thread-ul IO
    .observeOn(AndroidSchedulers.mainThread()) // Observă pe thread-ul UI
    .subscribe(/* Procesare rezultat */);

Avantaje: Instrument puternic pentru gestionarea evenimentelor asincrone și transformarea datelor, dar cu o barieră de intrare mai ridicată.

Biblioteca WorkManager:

WorkManager: Component recomandat din Architecture Components pentru executarea garantată a sarcinilor de fundal, chiar dacă aplicația este închisă sau dispozitivul repornește.

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

class MyWorker: Worker(appContext, workerParams) {
    override fun doWork(): Result {
        // Cod pentru executarea sarcinii în thread-ul de fundal
        return Result.success() // sau Result.failure(), Result.retry()
    }
}

// Crearea unei cereri de lucru
val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Limite opționale
    .build()

// Plasarea sarcinii în coadă
WorkManager.getInstance(context).enqueue(workRequest)

Avantaje: Executare garantată, suport pentru restricții (tip de rețea, baterie), gestionarea anulării, execuție întârziată și repetări.

Alegerea metodei specifice de executare a codului în thread paralel depinde de tipul sarcinii, ciclul de viață și cerințele de fiabilitate. Pentru majoritatea aplicațiilor Android moderne, se recomandă utilizarea Kotlin Coroutines sau WorkManager.

Cum se execută codul într-un thread paralel (nu principal)?