Kotlin RX .zipWith function body executes once or once per observer?

Question

When data is transmitted to my app, it follows a sequence of:

1 ReadStart packet with ID information
1 or more DataPackets that are combined to form the payload
1 ReadDone packet to signal the transfer is done

I have a Kotlin RX function that creates an Observable:

val readStartPublishProcessor: PublishProcessor<ReadStartPacket>
val dataPacketPublishProcessor: PublishProcessor<DataPacket>
val readDonePublishProcessor: PublishProcessor<ReadDonePacket>
...

private fun setupReadListener(): Flowable<ReadEvent> {
    val dataFlowable = dataPacketPublishProcessor.buffer(readDonePublishProcessor)
    
    return readStartPublishProcessor
        .zipWith(other = dataFlowable) { readStart, dataPackets ->
            Log.d(tag, "ReadEvent with ${dataPackets.size} data packets")
            ReadEvent(event = readStart, payload = combinePackets(dataPackets))
        }
}

From reading the documentation of .zipWith, I expect the .zipWith function body to execute once for each pair of values emitted from the readStartPublishProcessor and dataFlowable, and then pass that computed result to each subscriber:

The Zip method returns an Observable that applies a function of your choosing to the combination of items emitted, in sequence, by two (or more) other Observables, with the results of this function becoming the items emitted by the returned Observable. ... It will only emit as many items as the number of items emitted by the source Observable that emits the fewest items.

But if I have more than 1 observer I see the .zipWith function body executed the same number of times as the number of observers, each time with the same pair of emitted values. This is a problem because of side effects in the function called from within the .zipWith function body. (Note: neither .share nor .replay operators are not used in the observers.)

Why does is seem to be running the .zipWith function body for each observer rather than just once, and is there a way to write this so it only executes once regardless of the number of observers?

score 1 · Accepted Answer · answered Dec 01 '21 at 12:48

1

A couple of points...

The function called from within zipWith should not contain side effects. It should be a pure function. If you absolutely need side effects there, then use one of the do operators.

The observable returned from zipWith is cold (Observables are cold by default,) this means that every observer gets its own execution context. I.E., that the operator subscribes to its source observables every time that it is subscribed to and calls the function block it has for each subscription.

If you want subscriptions to share an execution context, then you must use the share or refCount operator. Learn more about Hot and Cold Observables here.

answered Dec 01 '21 at 12:48

Daniel T.

32,821
6
50
72

If the .zipWith body should be a pure function, why does it bother to execute it more than once for a given input pair? The results will be the same for each execution, and that is a waste of CPU cycles. – simpleuser Dec 04 '21 at 18:09
[Rx Design Guidelines](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwiswNyAisv0AhWgSDABHed9BqYQFnoECAUQAQ&url=http%3A%2F%2Fdownload.microsoft.com%2Fdownload%2F4%2FE%2F4%2F4E4999BA-BC07-4D85-8BB1-4516EC083A42%2FRx%2520Design%2520Guidelines.pdf), "The composition in Rx runs through each operator for each subscription (with the exception of the sharing operators, such as Publish). This will make every side-effect occur for each subscription. If this behavior is the desired behavior, it is best to make this explicit by putting the side-effecting code in a Do operator." – Daniel T. Dec 04 '21 at 21:26
It's precisely _because_ the block is called more than once that you should ensure that the block is pure. – Daniel T. Dec 04 '21 at 22:56
Buy why was it designed to waste cpu cycles calculating the same result multiple times? – simpleuser Dec 04 '21 at 22:59
That's why I included the link about Hot and Cold Observables. I suggest you read up on some of the philosophy behind Rx. If you still have questions, you can always ask them on the [software engineering stack exchange](https://softwareengineering.stackexchange.com), or here if they directly relate to code rather than philosophy. – Daniel T. Dec 05 '21 at 00:18

Kotlin RX .zipWith function body executes once or once per observer?

1 Answers1