Efficient way to keep state in reactive stream scan(), atomic, etc?

Question

Last time, I started implementing bitbay.net subscription on orders.

The problem is that bitbay is returning a delta of orders, but I always want to keep the whole price depth (so I have to keep full price depth on my side and update it when some delta event occur):

bid    ask                                        bid     ask
----------                                        -----------
A      D  ------------>delta-event(removed=D)---> A       F
B      F                                          B       G
C      G                                          C

So I decided to use

Flux
   .from(eventsFromBitbay)
   .scan(FullPriceDepth.empty(), (pd, e) -> pd.update(e))
   .subscription(...)

My question is Flux.scan(...) will be a good choice for that (in term of efficiency and thread safety)? I'm talking about millions of events in high spped system.

My alternative is to make some Atomic... and update it in Flux.create(...).map(e -> atomicHere) or is there something better?

Is Flux.scan() more efficient than Atomic..., why, why not?

Answer 1

"My question is Flux.scan(...) will be a good choice for that?"

Sure, why not? It's an obvious pattern, if you ask me. You have a class that holds information needed to process the flux. You should keep a couple things in mind though, mostly that the order of a flux is easy changed, for example by using Flux::flatMap instead of Flux::flatMapSequential, so you could easily get things in any order. Also, someone could put the flux on multiple threads so your FullPriceDepth properties might have to code for concurrency issues.