How to run two network requests simultaneously using…

Synchronizing the execution of two Coroutines directly with RxJava is impossible because they are two different paradigms of asynchronous programming. Coroutines use suspend functions and structured concurrency, while RxJava uses Observables and operators.

However, if you need to wait for two independent asynchronous operations to complete and continue only after both are finished (the "wait for all" pattern), you can use RxJava operators to combine results or wait for Observable completion.

An example using Coroutines for network requests and RxJava for their combination (using Completable.mergeArray or similar for waiting for completion if the requests return Completable, or combining results if they return Single or Maybe):

Suppose we have two suspend functions performing network requests:

interface ApiService {
    suspend fun fetchData1(): Data1
    suspend fun fetchData2(): Data2
}

And we want to run them in parallel and combine the results. First, convert the suspending functions into Observable or Single:

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import rx.Single
import rx.schedulers.Schedulers

fun CoroutineScope.fetchData1AsSingle(apiService: ApiService): Single<Data1> {
    return Single.create { subscriber ->
        launch {
            try {
                val data = apiService.fetchData1()
                subscriber.onSuccess(data)
            } catch (e: Throwable) {
                subscriber.onError(e)
            }
        }
    }.subscribeOn(Schedulers.io())
}

fun CoroutineScope.fetchData2AsSingle(apiService: ApiService): Single<Data2> {
    return Single.create { subscriber ->
        launch {
            try {
                val data = apiService.fetchData2()
                subscriber.onSuccess(data)
            } catch (e: Throwable) {
                subscriber.onError(e)
            }
        }
    }.subscribeOn(Schedulers.io())
}

Now, use RxJava operators to combine the results:

import rx.Single
import rx.android.schedulers.AndroidSchedulers
import rx.functions.Func2
import rx.singles.Singles

// ... within some scope where CoroutineScope is available
val scope: CoroutineScope = ... // e.g., viewModelScope

val single1: Single<Data1> = scope.fetchData1AsSingle(apiService)
val single2: Single<Data2> = scope.fetchData2AsSingle(apiService)

Singles.zip(
    single1,
    single2,
    Func2 { data1, data2 ->
        // Process the received data data1 and data2
        Pair(data1, data2) // Return combined result
    }
)
.observeOn(AndroidSchedulers.mainThread()) // Switch to main thread for UI work
.subscribe(
    { combinedResult ->
        // Handle combined result on main thread
        println("Got data1: ${combinedResult.first}, data2: ${combinedResult.second}")
    },
    { error ->
        // Handle errors
        error.printStackTrace()
    }
)

In this approach, Coroutines are used for executing the actual asynchronous operations (network requests), and RxJava manages threading (observeOn, subscribeOn) and combines the results of two independent Observables (zip).

Alternatively, with a full transition to Coroutines, parallel execution can be achieved using async and await:

import kotlinx.coroutines.*

suspend fun fetchDataParallel(apiService: ApiService): Pair<Data1, Data2> = coroutineScope {
    val deferred1 = async { apiService.fetchData1() }
    val deferred2 = async { apiService.fetchData2() }

    // Wait for both coroutines to complete
    val data1 = deferred1.await()
    val data2 = deferred2.await()

    Pair(data1, data2)
}

// Call from a CoroutineScope
scope.launch {
    try {
        val (data1, data2) = fetchDataParallel(apiService)
        // Process data
    } catch (e: Exception) {
        // Handle errors
    }
}

The second approach (pure Coroutines) is more preferable for new development or migration, as it eliminates the need to mix two different libraries for managing asynchrony.

How to run two network requests simultaneously using Coroutine with RxJava?