Какие знаешь варианты выполнения кода в другом потоке кроме корутин?

Многопоточность в Android (без Coroutines)

Корутины — это современный способ, но в Android есть много других механизмов для выполнения кода в других потоках. Каждый имеет свой случай использования. Вот полный обзор альтернатив.

1. Thread (низкоуровневый подход)

Основной инструмент для многопоточности в Java. Можно создавать и управлять потоками напрямую.

// Простой способ
Thread {
    val data = heavyComputation()
    // Обновить UI нужно на main потоке!
    runOnUiThread {
        textView.text = data
    }
}.start()

// С именем потока (удобнее для отладки)
Thread({
    fetchDataFromNetwork()
}, "FetchThread").apply {
    priority = Thread.NORM_PRIORITY
    isDaemon = false  // Приложение ждёт завершения
    start()
}

Плюсы:

• Максимум контроля
• Стандартное Java API

Минусы:

• Очень низкоуровнево
• Сложное управление жизненным циклом
• Риск утечек (поток не завершится если держит ссылку)
• Много boilerplate-кода

2. Handler + Thread/Message Queue

От древних времён Android. Handler позволяет отправлять задачи на главный поток или Looper.

// Handler на главном потоке
private val mainHandler = Handler(Looper.getMainLooper())

// Отправить задачу на главный поток
mainHandler.post {
    textView.text = "Обновлено"
}

// С задержкой
mainHandler.postDelayed({
    textView.text = "С задержкой"
}, 1000)  // 1 секунда

// Работать в фоновом потоке
Thread {
    val result = heavyComputation()
    mainHandler.post {
        updateUI(result)
    }
}.start()

// HandlerThread — поток с Looper
val handlerThread = HandlerThread("BackgroundThread")
handlerThread.start()
val handler = Handler(handlerThread.looper)
handler.post {
    // Код выполняется в фоновом потоке
}

Плюсы:

• Встроено в Android Framework
• Подходит для синхронизации между потоками
• Удобен для периодических задач

Минусы:

• Старый API, не очень удобный
• Много boilerplate
• Риск утечек памяти (Handler держит ссылку на Context)
• Callback hell при цепочке операций

3. Executor Service (Thread Pool)

Модель производитель-потребитель через пул потоков. Лучше чем создавать потоки вручную.

import java.util.concurrent.*

// Создать пул потоков
val executorService = Executors.newFixedThreadPool(4)  // 4 потока
val singleExecutor = Executors.newSingleThreadExecutor()  // Один поток
val cachedExecutor = Executors.newCachedThreadPool()  // Dynamic пул

// Отправить задачу
executorService.execute {
    val result = fetchDataFromNetwork()
    // Обновить UI
    runOnUiThread {
        textView.text = result
    }
}

// Отправить задачу с результатом
val future = executorService.submit<String> {
    fetchDataFromNetwork()
}

// Ждать результата (блокирует поток!)
val result = future.get()  // Опасно на главном потоке

// Более безопасно с callback
future.addListener({
    val result = future.get()
    runOnUiThread {
        updateUI(result)
    }
}, executorService)

// Завершить пул
executorService.shutdown()
// Или насильно
executorService.shutdownNow()

Плюсы:

• Управление ресурсами (пул вместо создания потоков)
• Future API для результатов
• Встроено в Java

Минусы:

• Callback-based (callback hell при цепочке)
• Нужно вручную управлять lifecycle
• Блокирующие операции (future.get())

4. AsyncTask (deprecated, но нужно знать)

Раньше это был стандартный способ в Android. Теперь deprecated в пользу Coroutines.

// Deprecated! Но примерно так выглядит
private inner class FetchDataTask : AsyncTask<String, String, String>() {
    override fun doInBackground(vararg params: String?): String {
        // Фоновый поток
        return fetchDataFromNetwork(params[0])
    }
    
    override fun onPostExecute(result: String?) {
        // Главный поток (UI обновляется здесь)
        textView.text = result
    }
    
    override fun onProgressUpdate(vararg values: String?) {
        // Главный поток, можно обновлять прогресс
        progressBar.progress = values[0].toInt()
    }
}

// Запустить
FetchDataTask().execute("url", "param2")

Плюсы:

• Автоматически переключается между потоками
• Встроено в Android

Минусы:

• Deprecated!
• Риск утечек памяти (inner class держит Context)
• Не отменяется при destroy Activity
• Сложно тестировать

5. RxJava / RxKotlin (Reactive Programming)

Мощная библиотека для асинхронных операций. Альтернатива Coroutines.

import io.reactivex.rxkotlin.subscribeBy
import io.reactivex.schedulers.Schedulers

// Observable на IO потоке
Observable.just("data")
    .subscribeOn(Schedulers.io())  // Фоновый поток
    .map { it.toUpperCase() }
    .observeOn(AndroidSchedulers.mainThread())  // Главный поток
    .subscribe(
        { result -> textView.text = result },  // onNext
        { error -> showError(error.message) },  // onError
        { println("Complete") }  // onComplete
    )

// Цепочка операций (Marble diagram читается слева направо)
Repository.getUsers()
    .subscribeOn(Schedulers.io())
    .filter { it.isActive }
    .flatMap { user -> Repository.getPostsForUser(user.id) }
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe { posts ->
        adapter.setData(posts)
    }

Плюсы:

• Мощный API для сложных асинхронных операций
• Трансформации потоков данных
• Встроенная обработка ошибок
• Composition

Минусы:

• Кривая обучения (marble диаграммы, operators)
• Может быть overkill для простых задач
• Вытесняется Coroutines
• Утечки подписки если не отписаться

6. Thread Pool + Callback Pattern

Это то, что часто используется в legacy-коде.

interface DataCallback {
    fun onSuccess(data: String)
    fun onError(error: Exception)
}

class DataManager {
    private val executor = Executors.newFixedThreadPool(2)
    
    fun fetchData(callback: DataCallback) {
        executor.execute {
            try {
                val result = heavyComputation()
                // Обновить UI
                Handler(Looper.getMainLooper()).post {
                    callback.onSuccess(result)
                }
            } catch (e: Exception) {
                Handler(Looper.getMainLooper()).post {
                    callback.onError(e)
                }
            }
        }
    }
}

// Использование
dataManager.fetchData(object : DataCallback {
    override fun onSuccess(data: String) {
        textView.text = data
    }
    
    override fun onError(error: Exception) {
        Toast.makeText(this@MainActivity, error.message, Toast.LENGTH_SHORT).show()
    }
})

Плюсы:

• Понятен
• Контроль над потоками

Минусы:

• Callback hell
• Нужно вручную обрабатывать ошибки
• Много boilerplate

Сравнительная таблица

Современная рекомендация

Для новых проектов: Coroutines + ViewModel + StateFlow

// Вот как это выглядит сейчас (лучше всех вариантов выше)
class MyViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch(Dispatchers.IO) {
            val result = repository.fetchData()
            withContext(Dispatchers.Main) {
                updateUI(result)
            }
        }
    }
}

Это:

• Простой и читаемый синтаксис
• Нет утечек памяти (lifecycle-aware)
• Встроенная отмена при destroy
• Встроенная обработка ошибок
• Производительнее чем threads

Корутины вытеснили все другие способы многопоточности в современном Android-разработке.