В чем разница между Coroutines и RxJava?

В чем разница между Coroutines и RxJava?

Coroutines и RxJava — это две разные парадигмы для асинхронного программирования в Kotlin/Java. Это два принципиально разных подхода, каждый со своими плюсами и минусами. На современном Android Coroutines стали стандартом, но знание RxJava остаётся важным для work with legacy кода.

Основная концепция

Coroutines — это lightweight потоки, которые могут быть приостановлены (suspended) и возобновлены. Это синхронный код, который выглядит как блокирующий, но на самом деле выполняется асинхронно.

RxJava — это библиотека для реактивного программирования. Ты работаешь с потоками данных (Observable, Flowable) и трансформациями через операторы (map, filter, flatMap).

Синтаксис и стиль

// COROUTINES — императивный стиль (что делать)
suspend fun loadUser(id: String): User {
    val response = apiService.getUser(id)  // Выглядит синхронным!
    return response
}

viewModelScope.launch {
    try {
        val user = loadUser("123")
        updateUI(user)
    } catch (e: Exception) {
        showError(e)
    }
}

// RxJava — декларативный стиль (описание потока)
fun loadUser(id: String): Single<User> {
    return apiService.getUser(id)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
}

loadUser("123")
    .subscribe(
        { user -> updateUI(user) },
        { error -> showError(error) }
    )

Ключевые различия

Примеры использования

// COROUTINES — простой запрос
class UserViewModel : ViewModel() {
    val user = MutableStateFlow<User?>(null)
    
    fun loadUser(id: String) {
        viewModelScope.launch {
            try {
                user.value = repository.getUser(id)
            } catch (e: Exception) {
                Log.e("Error", "Failed to load user", e)
            }
        }
    }
}

// RxJava — тот же код выглядит иначе
class UserViewModel : ViewModel() {
    val user = BehaviorSubject.createDefault<User?>(null)
    private val disposable = CompositeDisposable()
    
    fun loadUser(id: String) {
        disposable.add(
            repository.getUser(id)
                .subscribe(
                    { user: User -> this.user.onNext(user) },
                    { error: Throwable -> Log.e("Error", "Failed to load user", error) }
                )
        )
    }
    
    override fun onCleared() {
        super.onCleared()
        disposable.clear()
    }
}

Сложные сценарии

Coroutines — последовательные запросы:

viewModelScope.launch {
    val user = repository.getUser(id)  // Запрос 1
    val posts = repository.getPosts(user.id)  // Запрос 2
    updateUI(user, posts)
}

RxJava — тот же сценарий:

repository.getUser(id)
    .flatMap { user ->
        repository.getPosts(user.id)
            .map { posts -> Pair(user, posts) }
    }
    .subscribe { (user, posts) ->
        updateUI(user, posts)
    }

Coroutines — параллельные запросы:

viewModelScope.launch {
    val user = async { repository.getUser(id) }
    val posts = async { repository.getPosts(id) }
    
    updateUI(user.await(), posts.await())
}

RxJava — параллельные запросы:

Observable.zip(
    repository.getUser(id),
    repository.getPosts(id),
    { user, posts -> Pair(user, posts) }
)
.subscribe { (user, posts) ->
    updateUI(user, posts)
}

Обработка ошибок

// COROUTINES — натуральная try/catch
viewModelScope.launch {
    try {
        val data = repository.getData()
        updateUI(data)
    } catch (e: NetworkException) {
        showNetworkError()
    } catch (e: ValidationException) {
        showValidationError()
    } catch (e: Exception) {
        showGenericError()
    }
}

// RxJava — операторы для обработки
repository.getData()
    .doOnError { Log.e("Error", it) }
    .onErrorReturn { emptyList() }  // fallback значение
    .onErrorResumeWith { Observable.just(defaultData) }  // fallback Observable
    .subscribe { data -> updateUI(data) }

Отмена операций

// COROUTINES — автоматическая отмена
val job = viewModelScope.launch {
    val data = slowRepository.getData()
    updateUI(data)
}

// Если пользователь ушёл, job отменится автоматически
// viewModelScope.cancel() вызывается в onCleared()

// RxJava — ручное управление
val disposable = repository.getData()
    .subscribe { data -> updateUI(data) }

// Нужно вручную отменять
fun onDestroy() {
    disposable.dispose()
}

Backpressure (когда Emitter быстрее Consumer)

// COROUTINES — есть встроенный механизм через Flow
fun produceNumbers(): Flow<Int> = flow {
    for (i in 1..1000) {
        emit(i)
        delay(100)
    }
}

viewModelScope.launch {
    produceNumbers()
        .collect { number ->
            // Автоматически замедляется если collector медленный
            processNumber(number)
        }
}

// RxJava — явно через Flowable
fun produceNumbers(): Flowable<Int> = Flowable
    .interval(100, TimeUnit.MILLISECONDS)
    .map { it.toInt() }

repository.produceNumbers()
    .onBackpressureBuffer()  // или onBackpressureDrop()
    .subscribe { number -> processNumber(number) }

Когда использовать что

Coroutines:

• Новые проекты (это стандарт Google)
• Простые асинхронные операции
• Когда нужен чистый, читаемый код
• MVVM + LiveData/StateFlow
• Работа с Room, Retrofit в стандартном режиме

RxJava:

• Legacy проекты, где уже RxJava
• Сложные потоки трансформаций данных
• Когда нужна мощная функциональная обработка
• Real-time data streams (финансовые данные, игры)
• Когда нужен fine-grained контроль над потоками

Миграция с RxJava на Coroutines

// Было в RxJava
val observable: Observable<User> = getUser(id)
    .map { it.copy(name = it.name.uppercase()) }
    .filter { it.age > 18 }

// Стало в Coroutines
val flow: Flow<User> = flow {
    val user = getUser(id)
    emit(user.copy(name = user.name.uppercase()))
}
.filter { it.age > 18 }

Мой совет

На практике Coroutines являются современным стандартом для Android. Google официально рекомендует их, все новые библиотеки (Room, Retrofit, DataStore) имеют первоклассную поддержку Coroutines. Но знание RxJava всё ещё полезно для:

1. Работы с legacy кодом
2. Понимания реактивных концепций
3. Сложных потоков данных (хотя Coroutines + Flow тоже справляются)

Если я выбирал бы для нового проекта — 100% Coroutines. Если работаю с legacy — использую то, что есть, но постепенно мигрирую на Coroutines.