Rx swift RxSwift：如何并行运行多个观测值

我是Chinna。我是rxswift的新手。我有一个任务，就像我有一些函数，它们的行为就像可观测的一样。目前，所有这些观察都是按顺序执行的。因此，我的应用程序性能正在下降。我想并行执行所有这些函数。这些功能并不相互依赖。我试过使用zip函数，但它们是按顺序运行的

    return Observable.create({ (observer) -> Disposable in
_ = Observable.zip(
self.createOrAlterTable(call).subscribeOn(ConcurrentMainScheduler.instance),
self.formSchemaToSQLite(call,lastSyncTime: lastSyncTime).subscribeOn(ConcurrentMainScheduler.instance),
self.menuTableRecord(call, lastSyncTime: lastSyncTime).subscribeOn(ConcurrentMainScheduler.instance),
self.recordsTOSqlite(call,lastSyncTime: lastSyncTime).subscribeOn(ConcurrentMainScheduler.instance),
self.imagerecordsTOSqlite(call,lastSyncTime: lastSyncTime).subscribeOn(ConcurrentMainScheduler.instance),
self.syncGraphDBNode(call).subscribeOn(ConcurrentMainScheduler.instance),
self.syncSchemasToSQLServer(call).subscribeOn(ConcurrentMainScheduler.instance),
self.syncRecordsToSQLServer(call).subscribeOn(ConcurrentMainScheduler.instance)
).observeOn(MainScheduler.asyncInstance)
.subscribe(onNext: {
xdata,ydata,adata,bdata,cdata,ddata,edata,fdata in
print("All Operations Done");
})
return Disposables.create()

所有上述函数如下所示

func syncSchemasToSQLServer(_ call: CAPPluginCall) -> Observable<String>{
    return Observable.just("SYNC_SCHEMAS_TO_SQLSERVER")
}

func-syncSchemasToSQLServer（u调用：CAPPluginCall）->可观察{
返回Observable.just（“SYNC\u SCHEMAS\u TO\u SQLSERVER”）
}

但这些函数仍在不定期地执行。请帮我解决这个问题

已更新

    func example() -> Observable<String>{
      var res=  Observable.zip(
            doJob(1).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .default)),
            doJob(2).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .default)),
            doJob(3).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .default))
        )
        .debug("done")
        .subscribe()

   return Observable.just("Success");
    }
    
    func doJob(_ value: Int) -> Observable<Void> {
        return Observable.create { observer in
            print("starting job", value)
            sleep(3)
            print("done with job", value)
            observer.onNext(())
            observer.onCompleted()
            return Disposables.create()
        }
    }

func example（）->可观察{
var res=Observable.zip(
doJob（1）.subscribeOn（ConcurrentDispatchQueueScheduler（qos:.默认值）），
doJob（2）.subscribeOn（ConcurrentDispatchQueueScheduler（qos:.默认值）），
doJob（3）.subscribeOn（ConcurrentDispatchQueueScheduler（qos:.默认值））
)
.debug（“完成”）
.subscribe（）
可观察的回报。公正（“成功”）；
}
func doJob（u值：Int）->可观察{
返回可观察的。在中创建{observer
打印（“开始作业”，值）
睡眠（3）
打印（“完成作业”，值）
observer.onNext（（））
observer.onCompleted（）
返回一次性物品。创建（）
}
}

ConcurrentMainScheduler.instance不能并行运行。改用ConcurrentDispatchQueueScheduler。以下代码有效：

func example() {
    doAllJobs()
        .subscribe(onNext: { print($0) })
}

func doAllJobs() -> Observable<String>{
    Observable.zip(
        doJob(1).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .default)),
        doJob(2).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .default)),
        doJob(3).subscribeOn(ConcurrentDispatchQueueScheduler(qos: .default))
    )
    .map { _ in "Success" }
}

func doJob(_ value: Int) -> Observable<Void> {
    Observable.create { observer in
        print("starting job", value)
        sleep(3)
        print("done with job", value)
        observer.onNext(())
        observer.onCompleted()
        return Disposables.create()
    }
}

func示例（）{
多尔乔布斯（）
.subscribe（onNext:{print（$0）}）
}
func doAllJobs（）->可观察{
可观察的.zip(
doJob（1）.subscribeOn（ConcurrentDispatchQueueScheduler（qos:.默认值）），
doJob（2）.subscribeOn（ConcurrentDispatchQueueScheduler（qos:.默认值）），
doJob（3）.subscribeOn（ConcurrentDispatchQueueScheduler（qos:.默认值））
)
.map{在“Success”中}
}
func doJob（u值：Int）->可观察{
创建{observate in
打印（“开始作业”，值）
睡眠（3）
打印（“完成作业”，值）
observer.onNext（（））
observer.onCompleted（）
返回一次性物品。创建（）
}
}

这也会起作用：

func doAllJobs() -> Observable<String> {
    let scheduler = ConcurrentDispatchQueueScheduler(qos: .default)
    return Observable.zip(
        doJob(1).subscribeOn(scheduler),
        doJob(2).subscribeOn(scheduler),
        doJob(3).subscribeOn(scheduler)
    )
    .map { _ in "Success" }
}

func doAllJobs（）->可观察{
let scheduler=ConcurrentDispatchQueueScheduler（qos:.默认值）
return-Observable.zip(
doJob（1）.subscribeOn（调度程序），
doJob（2）.subscribeOn（调度程序），
doJob（3）.subscribeOn（调度程序）
)
.map{在“Success”中}
}

谢谢@Daniel。我将尝试这个方法，但我需要等待所有这些任务并行完成，因为我正在从另一个函数调用这个特定函数。但若我使用上述zip函数，那个么该方法就不会等待这些观察结果的完成。在完成所有这些观察结果之后，我需要将响应作为“成功”发送回调用方函数。请帮我一个忙。

zip

操作符在发出任何东西之前，会一直等到所有的内部可见光发出。直到它所有的内部观察都完成了，它才完成。在我上面发布的代码中，“done”仅在所有内部作业完成后发出一次。谢谢回复。我已经检查了一个响应，但是zip函数没有等到所有可观察到的完成。它正在返回-->returnobservable.just（“success”）在完成zip函数之前。你能在这个问题上再多探讨一下吗。我已经实现了与您提供给我的代码相同的代码。