Почему корутины в Kotlin лучше RxKotlin для асинхронных задач?

Корутины vs RxKotlin: что выбрать?

Отличный вопрос! Давай разберёмся на практике. RxKotlin — это мощная реактивная библиотека, но корутины стали стандартом в Kotlin по нескольким причинам. Главное отличие — корутины встроены в язык, а Rx — сторонняя библиотека.

1. Простота и читаемость кода

Твой пример с корутинами выглядит как синхронный код. Это ключевое преимущество. Сравни:

// RxKotlin
Observable.fromCallable { api.getUser() }
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .flatMap { user -> Observable.fromCallable { api.getPosts(user.id) } }
    .subscribe(
        { posts -> showPosts(posts) },
        { error -> Log.e("TAG", error.message) }
    )

// Корутины
CoroutineScope(Dispatchers.Main).launch {
    try {
        val user = withContext(Dispatchers.IO) { api.getUser() }
        val posts = withContext(Dispatchers.IO) { api.getPosts(user.id) }
        showPosts(posts)
    } catch (e: Exception) {
        Log.e("TAG", e.message)
    }
}

В корутинах ты используешь обычный try/catch, а не колбэки. Это снижает когнитивную нагрузку.

2. Легковесность

Корутины — это не потоки. Ты можешь запустить 100 000 корутин, и они будут работать на нескольких потоках. RxKotlin создаёт больше объектов (Observable, Disposable), что может привести к утечкам памяти, если забыть отписаться. В корутинах утечки решаются через CoroutineScope и structured concurrency:

class MyActivity : AppCompatActivity() {
    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())

    fun loadData() {
        scope.launch { /* ... */ }
    }

    override fun onDestroy() {
        super.onDestroy()
        scope.cancel() // отменяет все корутины
    }
}

3. Поддержка Structured Concurrency

Это главная фишка корутин. Если родительская корутина отменяется, все дочерние автоматически отменяются. В RxKotlin нужно вручную управлять Disposable и CompositeDisposable:

// RxKotlin — ручное управление
val disposable = CompositeDisposable()
disposable.add(observable.subscribe { ... })
disposable.clear() // нужно не забыть вызвать

// Корутины — автоматически
scope.launch {
    launch { /* дочерняя корутина */ }
    launch { /* ещё одна */ }
}
// scope.cancel() отменяет всё

4. Операторы и потоки данных

RxKotlin выигрывает в сложных сценариях с комбинированием потоков (combineLatest, merge, debounce). Но для большинства задач корутины предлагают аналоги через Flow:

// RxKotlin: debounce
Observable.create { emitter -> ... }
    .debounce(300, TimeUnit.MILLISECONDS)
    .subscribe { text -> search(text) }

// Корутины: Flow
flow { emit(...) }
    .debounce(300)
    .collect { text -> search(text) }

Flow — это реактивный аналог корутин, который поддерживает все нужные операторы.

Итог:

• Корутины — для 90% задач: загрузка данных, последовательные вызовы, фоновые операции. Проще, легче, безопаснее.
• RxKotlin — если нужно сложное комбинирование потоков (например, real-time чат с фильтрацией). Но даже в этом случае Flow покрывает большинство сценариев.

Начни с корутин — это современный стандарт Kotlin. RxKotlin изучай только если работаешь с легаси.