VICTOR GRAZI VP, NOMURA Reactive Programming is an emerging paradigm for non-blocking concurrent programming. This means you can have multiple workers without allocating resources to multiple threads! In this presentation we will take a look at what reactive programming is and why it has become so popular. Then we will look at Pivotal's Reactor implementation, along with a deep dive into some coding examples.

1. Agenda
• What is Reac+ve?
• Flux basics
• Marble diagrams
• Cold Fluxes
• Hot Fluxes
• Demos
• Basic opera+ons
• Controlling emission rate
• A@aching to a feed
1

2. What is Reac0ve?
• Alternate programming paradigm – think in terms of streams
instead of objects.
• Reac+ve Streams –high-performance, asynch stream processing
non-blocking back pressure.
• Declara+ve tools for concise, error free code, especially under
high load and concurrency.
• Simplify clean coding of asynchronous event driven
programming.
• The good news is, it does not change much from language to
language.
2

3. CloJure
Cross language support
Java
3
my_observable
.map(Name::firstName)
.map(String::toLowerCase)
.filter(x -> x.startsWith("bob"))
.dis+nct()
.toList()

4. 4
Problem: Merging many requests
NetflixAPI
Server Request Latency Network Latency
Device
Server

5. Maven Dependencies
5
<dependency>
<groupId>io.projectreactor</groupId>
<artifactId>reactor-core</artifactId>
</dependency>
<dependency>
<groupId>io.projectreactor.addons</groupId>
<artifactId>reactor-test</artifactId>
</dependency>

6. • Everything is a stream of messages
• Flux emits event messages (“Observable” in rx-java land)
• Subscribers consume messages
• Fluxes are immutable (opera+ons return new Fluxes)
Implements Publisher
Emits messages from:
• Remote services
• Data feeds
• Mouse events…
Subscriber
Consumes pushed messages:
• onNext()
• onError()
• onComplete()
Basic Model
6
Message stream
Examples:
• Events
• Query results
• Computa+ons
• Even errors!
Flux Subscriber

7. onNext()
onComplete() onError()
(onError() and onComplete() are terminal opera+ons.)
A Subscriber receives noFficaFons:!
public interface Subscriber<T>!
void onNext(T t); void
onComplete(); !
void onError(Throwable t); void
onSubscribe(); !
!
7

8. …AIaching a Subscriber
8
flux.subscribe(
v -> handleHappyPath(v), // happy path
error -> handleError(error), // error handler
// (optional)
() -> handle(“Done") // completion
// (optional)
);

9. Transform and combine Flux streams
Flux
.filter(…)
.subscribe(…)
9
• Or even
Flux
• Or
Flux
.map(…)
.subscribe(…)
Each transforma+on returns a new resultant Flux.
etc., etc., etc.
.filter(…)
.map(…)
.subscribe(…)
.filter(…)
.map(…)
.doOnNext(System.out::println)
.subscribe(…)

10. MARBLE DIAGRAMS
h@p://rxmarbles.com/ Interac+ve marble diagrams
10

11. Combine Fluxes to produce new Fluxes
Examples: merge – merges elements as they arrive.
zip – combines elements in sequence.
firstEmikng – returns the first stream to emit an element.
11
• Methods take one Flux as input and return another Flux.

12. Crea0ng a Flux
Flux.just(value) – Creates instance that emits the supplied
value(s).
Flux.fromIterable/fromArray(values) –
Accepts Collec+on<T> or array, creates a Flux<T>, which
emits the values of the collec+on.
Flux.range(i, n) – Produces n consecu+ve integers star+ng
from i.
Flux.interval(Dura+on.ofSeconds(n)) – Emits a count, every
n +me units
12
etc. etc. etc.

13. Transforming Fluxes
Methods take one stream as input and return another stream.
• Flux.take(n) – Takes first n elements only.
• Flux.skip(n) – Skips first n elements, then takes the rest
• Flux.distinct() – Returns a new Flux with duplicates eliminated.
• Flux.distinctUntilChanged() – Eliminates consecutive duplicates.
• Flux.filter((x)->condition()) – Retains elements matching filter condition.
• Flux.map(Some::mapper) – Replaces elements with other elements.
• Flux.flatMap(Some::mapper) – Replaces elements with Fluxes.
13

14. Time Filtering
thro@leFirst() – Takes only the first amer every n +me units
thro@leLast() – Takes only the last element amer every n +me units
debounce() – Takes only the last event of each set in the specified +me.
+meout() – Issues an excep+on if no events before +meout
14
Select elements based on timing
debounce

15. Difference between Java Stream API and Reac0ve
15
Java Streams ReacFve Streams
Pull based Push based
Basically a way to iterate
collec+ons declara+vely
A@ach to real-+me feeds
Generally synchronous data Real-+me, concurrency, flow control
Streams can only be used once Reac+ve streams are highly reusable
No control of +ming Control back-pressure strategies
No composi+on of streams Advanced composi+on and
transforma+on
Finite amount of data Data sizes from zero to infinity

16. Concurrency
• Observers are synchronous; concurrent calls are
handled in sequence
• No need to code defensively for concurrency
• And no loss in latency due to synchroniza+on
16

17. Asynchronous Streams
Built in support for concurrent publishers and subscribers
• Flux.observeOn(scheduler) – Specifies the thread for the Observer
• Flux.subscribeOn(scheduler) – Specifies the thread for the Subscriber
Types of schedulers
• Schedulers.immediate() – Parks current process and uses current thread
• Schedulers.computa2on() – The system-assigned computa+on thread
• Schedulers.io() – The system-assigned IO thread
• Schedulers.trampoline() – Uses the current thread, once it is done here
• Schedulers.newThread() – Uses a new thread
• Schedulers.from(Executor) – On the named executor
17

18. Cold Fluxes and Hot Fluxes
18
• Cold Fluxes
• Won’t begin pumping un+l a subscriber is a@ached.
• Each subscriber receives all of the events, beginning
from the historical first.
• Hot Fluxes
• Generally read live data, for example data feeds or
mouse movements.
• Begin pumping on connec+on.
• Each subscriber gets the latest feeds as they pump

19. Addi0onal Cold Fluxes (for Development)
• Flux.empty() – Completes on the first subscrip+on, without
emikng any values.
• Flux.never() – Emits no values and never completes.
• Flux.error() – Emits an onError() no+fica+on immediately on
every subscriber. No other values are emi@ed.
• Flux.doOnNext() – Diagnos+cs
19

20. Crea0ng Hot Fluxes (Flowables)
20
o Call “publish” on a cold Flux
ConnectableFlux<Long> hotFlux =
coldFlux.publish();
o Call “connect” to start pumping, with or without subscribers
hotFlux.connect();
hotFlux.subscribe(
val -> System.out.println("Subscriber >> " +val));

21. Introducing Reac0ve Programming
Pivotal’s Reactor
Victor Grazi
GMIT Core IT
Demo

22. Victor Grazi
GMIT Core IT
Introducing Reac0ve Programming
Pivotal’s Reactor
Victor Grazi
GMIT Core IT
? ? ?
Q&A
?

23. Coun0ng le[ers
23
List<String> words = Arrays.asList(
"the",
"quick",
"brown",
"fox",
"jumps",
"over",
"the",
"lazy",
"dog"
);
Flux<Integer> lines = Flux.range(1, Integer.MAX_VALUE);
Flux<String> wordsFlux = Flux.fromIterable(words);
wordsFlux
.flatMap(word -> Flux.fromArray(word.split("")))
.distinct()
.sort()
.zipWith(lines, (word, line) -> line + " " + word)
.subscribe(System.out::println);

24. Metronome example
24
Flux<Long> fast = Flux.interval(Duration.ofSeconds(1));
Flux<Long> slow = Flux.interval(Duration.ofSeconds(3));
Flux<Long> clock = Flux.merge(
fast.filter(t -> isFastTime()),
slow.filter(t -> isSlowTime())
);
Flux<LocalDateTime> dateEmitter = Flux.interval(Duration.ofSeconds(1))
.map(t -> LocalDateTime.now());
Flux<LocalDateTime> localDateTimeFlux = clock.withLatestFrom(dateEmitter, (tick, date) -> date);
localDateTimeFlux.subscribe(t ->
System.out.println(t.format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"))));

25. Emi[er sample
25
SomeFeed<PriceTick> feed = new SomeFeed<>();
Flux<Object> priceFlux = Flux.create(emitter ->
{
SomeListener l = new SomeListener() {
@Override
public void priceTick(PriceTick event) {
emitter.next(event);
}
@Override
public void error(Throwable throwable) {
emitter.error(throwable);
}
};
feed.register(l);
}, FluxSink.OverflowStrategy.LATEST);
ConnectableFlux<Object> connectableFlux = priceFlux.publish();
connectableFlux.connect();
connectableFlux.subscribe(System.out::println);