RxJava中嵌套的Single.flatMap与Single.zip是否相同？

我面临一个困惑，通过示例4单曲给出：

val s1:Single=service1.execute（）.subscribeOn（io（））
val s2:Single=service2.execute（）.subscribeOn（io（））
val s3:Single=service3.execute（）.subscribeOn（io（））
val s4:Single=service4.execute（）.subscribeOn（io（））
瓦尔。。。。
val s10:Single=service10.execute（）.subscribeOn（io（））

数据类MyObj( 字段1：字符串， 字段2:Int， 字段3:Int， 字段4：字符串。。。 .... 字段10:Int )

我有一个

service10.execute（s1:strings2:ints3:ints4:String）

如果我这样做：

s1.flatMap{str->
s2.flatMap{int1->
s3.flatMap{int2->
s4.flatMap{str2->
...
s10.flatmap{int10
执行（myObj（str，int1，int2，str2…，int10））
}
}
}
}
}

与执行以下操作相同：

Single.zip(
列表(
s1，
s2，
s3，
s4
...,
...,
s10
)
){数组->
val str=数组[0]作为字符串
val int1=数组[1]为Int
val int2=数组[2]作为Int
val str2=数组[3]作为字符串
...
val str10=数组[9]为Int
}

1） flatMap在那里并行执行吗？

---

2） 如果嵌套的平面图是连续的，有没有办法使它们像zip一样并行？

没有，嵌套的

flatMap

s不会使

单个
s并行运行，如下测试证明：

    // so we can be sure service1 and service2 are active
    val bothSubscribed = CountDownLatch(2)
    // so we can simulate a blocking, long running operation on both services
    val subscribeThreadsStillRunning = CountDownLatch(1)

    val service5 = { str: String, str2: String ->
        Observable.just("service5: $str, $str2").singleOrError()
    }

    val scheduler = Schedulers.io()

    val createSingle = { value: String ->
        Observable
            .create<String> { emitter ->
                println("subscribe $value on ${Thread.currentThread().name}")
                bothSubscribed.countDown()
                subscribeThreadsStillRunning.await(10, SECONDS)
                emitter.onNext(value)
            }
            .singleOrError()
            .subscribeOn(scheduler)
    }

    val s1 = createSingle("outer")
    val s4 = createSingle("inner")

    s1.flatMap { outer ->
        s4.flatMap { inner ->
            service5(outer, inner)
        }
    }.subscribe()

    assert(bothSubscribed.await(5, SECONDS))
    subscribeThreadsStillRunning.countDown()

请注意，我使用了来自“io.reactivex.rxjava3:rxkotlin:3.0.0-RC1”的
Singles
，因为lambda可以更好地与Kotlin一起工作。
不，嵌套的
flatMap
不会使
Single
并行运行，如下测试证明了这一点：

    // so we can be sure service1 and service2 are active
    val bothSubscribed = CountDownLatch(2)
    // so we can simulate a blocking, long running operation on both services
    val subscribeThreadsStillRunning = CountDownLatch(1)

    val service5 = { str: String, str2: String ->
        Observable.just("service5: $str, $str2").singleOrError()
    }

    val scheduler = Schedulers.io()

    val createSingle = { value: String ->
        Observable
            .create<String> { emitter ->
                println("subscribe $value on ${Thread.currentThread().name}")
                bothSubscribed.countDown()
                subscribeThreadsStillRunning.await(10, SECONDS)
                emitter.onNext(value)
            }
            .singleOrError()
            .subscribeOn(scheduler)
    }

    val s1 = createSingle("outer")
    val s4 = createSingle("inner")

    s1.flatMap { outer ->
        s4.flatMap { inner ->
            service5(outer, inner)
        }
    }.subscribe()

    assert(bothSubscribed.await(5, SECONDS))
    subscribeThreadsStillRunning.countDown()

请注意，我使用了
中的
单选项
“io.reactivex.rxjava3:rxkotlin:3.0.0-RC1”
，因为lambda与Kotlin的配合更好。
另请参见flatZip讨论另请参见flatZip讨论