Как да изпълним код в паралелен (не главен) поток…

За паралелното изпълнение на код в Android се използват различни механизми, които позволяват да не блокирате главния (UI) поток и да запазите отзивчивостта на приложението.

Стандартните средства на Android:

Thread: Основен клас за създаване на нов поток.
```
new Thread(new Runnable() {
    @Override
    public void run() {
        // Код за изпълнение в паралелен поток
    }
}).start();
```
Недостатък: Ръчното управление на потоковете може да доведе до проблеми с жизнения цикъл и изтичане на памет.

AsyncTask (остарял): Опрощава работата с паралелни потоци и взаимодействието с UI потока.

private static class MyAsyncTask extends AsyncTask<Void, Void, Void> {
    @Override
    protected Void doInBackground(Void... params) {
        // Код за изпълнение във фоновия поток
        return null;
    }

    @Override
    protected void onPostExecute(Void result) {
        // Работа с UI потока след завършване на doInBackground
    }
}
// Използване: new MyAsyncTask().execute();

Минуси: Остарял е, има ограничения и трудности при управление на жизнения цикъл.

Handler и Looper: Позволяват създаването на потоци с цикли за обработка на съобщения.
```
HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();
Handler handler = new Handler(handlerThread.getLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        // Код за изпълнение в поток с Looper
    }
});
```
Предимство: Удобно за изпълнение на повтарящи се задачи или обработка на асинхронни събития в отделен поток.

ExecutorService / ThreadPoolExecutor: Предоставят пулове от потоци, което е по-ефективно, отколкото създаването на нов Thread за всяка задача.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Или newCachedThreadPool(), newFixedThreadPool(N)
executor.execute(new Runnable() {
    @Override
    public void run() {
        // Код за изпълнение в поток от пула
    }
});
// Не забравяйте да извикате executor.shutdown() при приключване

Предимства: Управляват създаването и повторното използване на потоци, намаляват разходите.

Съвременни подходи:

Kotlin Coroutines: Леките потоци, които предоставят по-опростен и четим начин за асинхронно програмиране.

import kotlinx.coroutines.*

// Стартиране на корутина в пул от потоци (аналог на фонов поток)
GlobalScope.launch(Dispatchers.Default) {
    // Код за изпълнение във фоновия поток
}

// Стартиране на корутина за работа с IO операции
GlobalScope.launch(Dispatchers.IO) {
    // Код за изпълнение на IO операции (работа с мрежа, файлове и др.)
}

// Превключване към UI поток за актуализиране на потребителския интерфейс
GlobalScope.launch(Dispatchers.Default) {
    // Фонови изчисления
    withContext(Dispatchers.Main) {
        // Актуализация на UI
    }
}

Предимства: Подобрява четимостта на кода, по-ефективно използване на ресурсите, лесно управление на отменяне на задачи, структурирана конкуренция.

RxJava / RxKotlin: Реактивно програмиране, базирано на наблюдаеми потоци от данни.

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

Observable.just("Някакъв резултат")
    .subscribeOn(Schedulers.io()) // Изпълнение в IO поток
    .observeOn(AndroidSchedulers.mainThread()) // Наблюдение в UI поток
    .subscribe(/* Обработка на резултата */);

Предимства: Мощен инструмент за работа с асинхронни събития и преобразуване на данни, но има по-висок праг за влизане.

Библиотеката WorkManager:

WorkManager: Препоръчаният компонент от Architecture Components за гарантирано изпълнение на фонови задачи, дори ако приложението е затворено или устройството е рестартирано.

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

class MyWorker: Worker(appContext, workerParams) {
    override fun doWork(): Result {
        // Код за изпълнение на задачата във фоновия поток
        return Result.success() // Или Result.failure(), Result.retry()
    }
}

// Създаване на заявка за изпълнение на задачата
val workRequest = OneTimeWorkRequestBuilder<MyWorker>()
    .setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build()) // Опционални ограничения
    .build()

// Поставяне на задачата в опашката
WorkManager.getInstance(context).enqueue(workRequest)

Предимства: Гарантирано изпълнение, поддръжка на ограничения (тип мрежа, заряд на батерията), управление на отмяна, отложено изпълнение и повторения.

Изборът на конкретен метод за изпълнение на код в паралелен поток зависи от типа на задачата, нейния жизнен цикъл и изискванията за надеждност на изпълнението. За повечето съвременни Android приложения се препоръчва използването на Kotlin Coroutines или WorkManager.

Как да изпълним код в паралелен (не главен) поток?