RxSwift Observable竞态条件问题：flatMap相关方法调用时机异常如何修复？

Hey there! Let's figure out why createChildObject(with:) is running before observer.onNext(element) and how to fix it.

First, let's break down the root cause: When using flatMap, the closure you pass to it runs immediately whenever the source Observable emits an element. If you're calling createChildObject at the start of that closure, it will execute before you even create or send events through the child Observable—this is just how flatMap's execution flow works.

The fix depends on exactly what you're trying to achieve, so here are the most common solutions tailored to different scenarios:

Scenario 1: You want createChildObject to run after the subscriber receives the element #

If your goal is to first send the original element to subscribers, then trigger the child object creation, move the createChildObject call into a do(onNext:) operator. This ensures the creation logic only runs after the element is delivered:

// Before (create runs early)
selectedElement = sourceObservable.flatMap { element in
    let child = createChildObject(with: element) // Runs before onNext
    return Observable.just(element)
}

// After (create runs after subscriber gets the element)
selectedElement = sourceObservable
    .flatMap { element in
        Observable.just(element)
            .do(onNext: { _ in
                createChildObject(with: element) // Triggers after onNext
            })
    }

Scenario 2: You want createChildObject to only run when someone subscribes to selectedElement #

If flatMap is creating the child object too early (even when no one is subscribed to selectedElement), wrap the creation logic in Observable.deferred. This delays execution of createChildObject until a subscriber actually connects to the Observable:

// Before (create runs as soon as source emits an element)
selectedElement = sourceObservable.flatMap { element in
    let child = createChildObject(with: element) // Runs immediately
    return Observable.just(child)
}

// After (create runs only on subscription)
selectedElement = sourceObservable.flatMap { element in
    Observable.deferred {
        let child = createChildObject(with: element) // Runs when subscribed
        return Observable.just(child)
    }
}

Scenario 3: You need to send the original element first, then send the created child object #

If you want subscribers to receive the original element first, then get the child object after it's created, use Observable.concat to sequence the two events properly:

selectedElement = sourceObservable.flatMap { element in
    // First, send the original element
    let sendOriginal = Observable.just(element)
    // Then, create the child and send it
    let createAndSendChild = Observable.create { observer in
        let child = createChildObject(with: element)
        observer.onNext(child)
        observer.onCompleted()
        return Disposables.create()
    }
    // Ensure the original element is sent before the child
    return Observable.concat([sendOriginal, createAndSendChild])
}

Pick the solution that matches your exact use case—each addresses a different timing issue with flatMap and createChildObject.

内容的提问来源于stack exchange，提问作者DesperateLearner