¿Cómo ejecutar código en un hilo paralelo (que no sea…

Para la ejecución paralela de código en Android, se utilizan diversos mecanismos que permiten no bloquear el hilo principal (UI) y mantener la capacidad de respuesta de la aplicación.

Medios integrados de Android:

Thread: Clase base para crear un nuevo hilo.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Código para ejecutar en un hilo paralelo
    }
}).start();

Desventaja: La gestión manual de hilos puede causar problemas con el ciclo de vida y fugas de memoria.

AsyncTask (Obsoleto): Facilitaba el trabajo con hilos paralelos y la interacción con el hilo UI.

private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        // Código para ejecutar en segundo plano
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        // Trabajo con el hilo UI después de doInBackground
    }
}
// Uso: new MyAsyncTask().execute();

Desventajas: Está obsoleto, tiene limitaciones y dificultades en la gestión del ciclo de vida.

Handler y Looper: Permiten crear hilos con bucles de procesamiento de mensajes.

HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        // Código para ejecutar en el hilo con Looper
    }
});

Ventaja: Útil para tareas repetitivas o manejo de eventos asíncronos en un hilo separado.

ExecutorService / ThreadPoolExecutor: Proporcionan grupos de hilos, más eficiente que crear un nuevo Thread para cada tarea.

ExecutorService executor = Executors.newSingleThreadExecutor(); // O newCachedThreadPool(), newFixedThreadPool(N)
executor.execute(new Runnable() {
    @Override
    public void run() {
        // Código para ejecutar en un hilo del grupo
    }
});
// No olvidar llamar a executor.shutdown() al finalizar

Ventajas: Gestionan la creación y reutilización de hilos, reduciendo costos.

Enfoques modernos:

Kotlin Coroutines: Hilos ligeros que ofrecen una forma más sencilla y legible de programación asíncrona.

import kotlinx.coroutines.*

// Iniciar una coroutine en un grupo de hilos (similar a un hilo de fondo)
GlobalScope.launch(Dispatchers.Default) {
    // Código para ejecutar en segundo plano
}

// Iniciar una coroutine para operaciones de IO
GlobalScope.launch(Dispatchers.IO) {
    // Código para operaciones de IO (red, archivos, etc.)
}

// Cambiar al hilo UI para actualizar la interfaz
GlobalScope.launch(Dispatchers.Default) {
    // Cálculos en segundo plano
    withContext(Dispatchers.Main) {
        // Actualizar UI
    }
}

Ventajas: Mejor legibilidad, uso eficiente de recursos, gestión sencilla de cancelaciones, concurrencia estructurada.

RxJava / RxKotlin: Programación reactiva basada en flujos de datos observables.

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

Observable.just("Algún resultado")
    .subscribeOn(Schedulers.io()) // Ejecutar en hilo IO
    .observeOn(AndroidSchedulers.mainThread()) // Observar en hilo UI
    .subscribe(/* Procesar resultado */);

Ventajas: Herramienta potente para eventos asíncronos y transformación de datos, con una curva de aprendizaje más alta.

Biblioteca WorkManager:

WorkManager: Componente recomendado de Architecture Components para garantizar la ejecución de tareas en segundo plano, incluso si la aplicación está cerrada o el dispositivo se reinicia.

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

class MyWorker(appContext: Context, workerParams: WorkerParameters): Worker(appContext, workerParams) {
    override fun doWork(): Result {
        // Código para ejecutar en segundo plano
        return Result.success() // O Result.failure(), Result.retry()
    }
}

// Crear una solicitud para ejecutar la tarea
val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Restricciones opcionales
    .build()

// Encolar la tarea
WorkManager.getInstance(context).enqueue(workRequest)

Ventajas: Ejecución garantizada, soporte para restricciones (tipo de red, batería), gestión de cancelaciones, ejecuciones diferidas y repeticiones.

La elección del método específico para ejecutar código en un hilo paralelo depende del tipo de tarea, su ciclo de vida y los requisitos de fiabilidad. Para la mayoría de las aplicaciones Android modernas, se recomienda usar Kotlin Coroutines o WorkManager.

¿Cómo ejecutar código en un hilo paralelo (que no sea el principal)?