The document discusses reactive streams and how they can be used to simplify reactive programming and increase an application's abstraction level. It provides an overview of reactive streams specifications and key interfaces like Publisher, Subscriber, and Subscription. Examples are given showing how reactive streams can be implemented in different frameworks like Akka Streams, Spring Reactor, RxJava, Ratpack, and Vert.x to provide interoperability. Reactive streams allow building reactive applications from components using different frameworks.

1. Reactiv
e
Stream
s

2. THEN
Java Developer
LATER
Enterprise
Architect
NOW
Scala Consultant
TWITTER
@slavaschmidt
MAIL
slavaschmidt@gmx.d
e
Reactiv
e
Stream
s

3. Stream

4. A stream can be defined as a sequence of
data.
A powerful concept that greatly simplifies I/
O operations.
Java 5/6/7

5. A sequence of elements
supporting sequential and
parallel aggregate operations.
Java 8

6. •sequence of data or instructions
•hot or cold
•bounded or unbounded
•focus on data transfer and/or
transformation

7. Uses

8. •bulk data transfer
•batch processing of large data sets
•micro-batching
•real-time data sources
•embedded data-processing
•monitoring and analytics
•metrics, statistics composition
•event processing
•error handling

11. MEET
ALICE AND
BORIS

12. MEET
ALICE AND
BORIS

13. Java 6

14. Java 7

18. Java 8

19. NAK (NACK)

20. Backpressure

21. Reactive Stream

22. MEET
ALICE AND BORIS
•Typical threads
•Do some work
•Exchange data

23. Direct Calls
private static final SThread alice =
new SThread("RS-Alice") {
@Override public void swap(int count) {
super.swap(count);
borice.swap(count);
}
};
private static final SThread borice =
new SThread("RS-Borice") {
@Override public void run() {
while (!stopped()) { SwapEnvironment.work(); }
}
@Override public void swap(int count) {
super.swap(count);
}
};

24. Java
IO
“Let’s move some data”

25. Java IO
A PipedOutputStream
PipedInputStream
protected byte buffer[];
B

26. Java IO
A PipedOutputStream B
PipedInputStream
protected byte buffer[];

27. Java IO
A PipedOutputStream BPipedInputStream
Write
Block
Transfer
Block
Read
Block

28. Java IO
val alice = new SThread("RS-Alice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateA) out.write(Env.BEER)
}
}
val borice = new SThread("RS-Borice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateB) in.read()
}
}
val out = new PipedOutputStream()
val in = new PipedInputStream(out, size)

29. Java IO
val alice = new SThread("RS-Alice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateA) out.write(Env.BEER)
}
}
val borice = new SThread("RS-Borice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateB) in.read()
}
}
val out = new PipedOutputStream()
val in = new PipedInputStream(out, size)
INCREASE

30. Java IO
val alice = new SThread("RS-Alice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateA) out.write(Env.BEER)
}
}
val borice = new SThread("RS-Borice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateB) in.read()
}
}
val out = new PipedOutputStream()
val in = new PipedInputStream(out, size)
INCREASE

31. Java IO
val alice = new SThread("RS-Alice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateA) out.write(Env.BEER)
}
}
val borice = new SThread("RS-Borice") {
override def swap(n: Int) {
super.swap(n)
for (i <- 0 to n * rateB) in.read()
}
}
val out = new PipedOutputStream()
val in = new PipedInputStream(out, size)
INCREASE

32. Blocking is only a matter of time :(
Java
IO

33. Java NIO
“There is a better way”

34. Java NIO
A SinkChannel BSourceChannel
Write
Block
Transfer
BufferBuffer
Read
Block
Read
Fill

35. Java NIOval alice = new SThread("RS-Alice") {
override def swap(n: Int) {
val cnt = n * rateA
val buffer = ByteBuffer.allocate(cnt)
buffer.put(Vector.fill(cnt)(BEER).toArray)
buffer.flip()
val written = sinkChannel.write(buffer)
super.swap(written)
}
}
val borice = new SThread("RS-Borice") {
override def swap(n: Int) {
val buffer = ByteBuffer.allocate(n * rateB)
val cnt = sourceChannel.read(buffer)
super.swap(cnt)
}
}
val pipe = Pipe.open()
val sinkChannel = pipe.sink
val sourceChannel = pipe.source
sourceChannel.configureBlocking(true)
sinkChannel.configureBlocking(false)
BLOCKING

36. Java NIOval alice = new SThread("RS-Alice") {
override def swap(n: Int) {
val cnt = n * rateA
val buffer = ByteBuffer.allocate(cnt)
buffer.put(Vector.fill(cnt)(BEER).toArray)
buffer.flip()
val written = sinkChannel.write(buffer)
super.swap(written)
}
}
val borice = new SThread("RS-Borice") {
override def swap(n: Int) {
val buffer = ByteBuffer.allocate(n * rateB)
val cnt = sourceChannel.read(buffer)
super.swap(cnt)
}
}
val pipe = Pipe.open()
val sinkChannel = pipe.sink
val sourceChannel = pipe.source
sourceChannel.configureBlocking(false)
sinkChannel.configureBlocking(false)
NON-BLOCKING

37. “Choose how to fail”
Java NIO

38. IO & NIO

39. IO & NIO
Blocking
Dropping
or
Unbounded
or
Non-Determinism
OutOfMemory
Scalability

40. Solution
Backpressure

41. Solution
Backpressure
Dynamic Push/Pull
Fast Boris

42. Solution
Backpressure
Dynamic Push/Pull
Fast Alice

43. Backpressure
A BStream
Data
Demand
Data
Demand

44. Java
8

45. Java 8
public class ConsumerBorice extends SThread implements Consumer<byte[]> {
public ConsumerBorice(String name) {
super(name);
}
@Override
public Consumer andThen(Consumer after) {
return after;
}
@Override
public void accept(byte[] bytes) {
super.swap(bytes.length);
}
}

46. Java 8
private static final ConsumerBorice borice =
new ConsumerBorice("RS-Borice") {
public void swap(int count) { }
};
private static final SThread alice = new SThread ("RS-Alice") {
byte[] items(int count) {
byte[] result = new byte[count];
Arrays.fill(result, Env.BEER());
return result;
}
public void swap(int count) {
Stream.of(items(count)).parallel()
.filter(s -> s.equals(Env.BEER()))
.forEach(borice);
super.swap(count);
}
};

47. Java 8
private static final ConsumerBorice borice =
new ConsumerBorice("RS-Borice") {
public void swap(int count) { }
};
private static final SThread alice = new SThread ("RS-Alice") {
byte[] items(int count) {
byte[] result = new byte[count];
Arrays.fill(result, Env.BEER());
return result;
}
public void swap(int count) {
Stream.of(items(count)).parallel()
.filter(s -> s.equals(Env.BEER()))
.forEach(borice);
super.swap(count);
}
};
transformation
static push (or pull)
or sequential

48. Java 8
private static final ConsumerBorice borice =
new ConsumerBorice("RS-Borice") {
public void swap(int count) { }
};
private static final SThread alice = new SThread ("RS-Alice") {
byte[] items(int count) {
byte[] result = new byte[count];
Arrays.fill(result, Env.BEER());
return result;
}
public void swap(int count) {
Stream.of(items(count)).parallel()
.filter(s -> s.equals(Env.BEER()))
.forEach(borice);
super.swap(count);
}
}; Synchronous
Non-Deterministic
Limited Scalability
Terminates on error

49. Problems
Synchronous
Non-Deterministic
Limited Scalability
Terminates on error

50. Problems
Synchronous
Non-Deterministic
Limited Scalability Terminates on error

51. Message Driven
Responsive
Elastic Resilient

52. Reactive
Message Driven
Responsive
Elastic Resilient
http://www.reactivemanifesto.org

53. Reactive Streams
… a standard for
asynchronous stream
processing with non-
blocking backpressure.
http://www.reactive-streams.org

54. Participants
Netflix rxJava, rxScala, …
Oracle
Pivotal Spring Reactor
RedHat Vert.x
Twitter
Typesafe Akka Streams
Ratpack

55. Reactive Streams
• Semantics (Specification)
• API (Application Programming Interface)
• TCK (Technology Compatibility Kit)

56. API
public interface Publisher<T> {
void subscribe(Subscriber<? super T> var1);
}
public interface Subscriber<T> {
void onSubscribe(Subscription var1);
void onNext(T var1);
void onError(Throwable var1);
void onComplete();
}
public interface Subscription {
void request(long var1);
void cancel();
}

57. Subscription
Subscription
subscribe
onSubscribe
Producer Subscriber

58. Streaming
request
Subscription
onNext
onComplete
onError
cancel
Subscriber

59. trait BytePublisher extends Publisher[Byte] {
var subscriber: Subscriber[_ >: Byte] = _
override def subscribe(subscriber: Subscriber[_ >: Byte]) {
this.subscriber = subscriber
}
}
val alice = new SThread("RS-Alice") with BytePublisher {
override def swap(n: Int) {
for { i <- 1 to n } subscriber.onNext(Env.BEER)
super.swap(n)
}
}
Publisher

60. trait ByteSubscriber[T >: Byte] extends Subscriber[T] {
var subscription: Subscription = _
override def onSubscribe(subscription: Subscription) {
this.subscription = subscription
}
override def onError(t: Throwable) { }
override def onComplete() { }
}
val borice = new SThread(“RS-Borice") with ByteSubscriber[Byte]{
def onNext(t: Byte) {
super.swap(1)
}
}
Subscriber

61. val borice = new SThread(“RS-Borice") with ByteSubscriber[Byte]{
alice.subscribe(this)
override def swap(n: Int) {
subscription.request(n)
}
def onNext(t: Byte) {
super.swap(1)
}
}
Right Subscriber

62. val alice = new SThread("RS-Alice") with BytePublisher {
override def swap(n: Int) {
val cnt = math.min(n, counter.get())
counter.addAndGet(-cnt)
for { i <- 1 to cnt } subscriber.onNext(Env.BEER)
super.swap(n)
}
}
Right Publisher
trait BytePublisher extends Publisher[Byte] {
var subscriber: Subscriber[_ >: Byte] = _
var subscription: Subscription = _
val counter = new AtomicInteger(0)
def request(l: Long): Unit = {
counter.addAndGet(l.toInt)
}
override def subscribe(subscriber: Subscriber[_ >: Byte]) {
this.subscription = new ByteSub(this)
this.subscriber = subscriber
subscriber.onSubscribe(this.subscription)
}
}

63. implicit val mat = FlowMaterializer()(system)
Source(alice).runWith(Sink(borice))
Akka Streams

64. Streams.create(alice).subscribe(borice)
Reactor Stream

65. ratpack.stream.Streams.buffer(alice).subscribe(borice)
Ratpack.io

66. import rx.RxReactiveStreams._
subscribe(toObservable(alice), borice)
RxReactiveStrea
ms

67. //vert.x 3.0 - only supports Streams[Buffer]
val rws = ReactiveWriteStream.writeStream()
rws.subscribe(borice)
val rrs = ReactiveReadStream.readStream()
alice.subscribe(rrs)
val pump = Pump.pump(rrs, rws)
pump.start()
Vert.X

68. Why
should
I care?

69. Because
•Simplifies reactive programming
•Rises program’s abstraction level
•May be future JDK standard

70. Abstraction levels

71. Abstraction levels
Runnable &Thread

72. Abstraction levels
java.util.concurrent

73. Abstraction levels
Promise & Future

74. Abstraction levels
Actors

75. Abstraction levels
Streams

76. Abstraction levels

77. Interoperability

78. Shop Admin
Delivery
WebShop
Merchant
ADs Stats

79. Shop Admin
Delivery
WebShop
Merchant
ADs Stats
DB
REST
File System
Messaging
REST

80. Shop Admin
(vert.x)
Delivery
(Spring)
WebShop
(Akka)
Merchant
(ratpack.io)
ADs
(Rx…)
Stats
(Spray)
DB
REST
File System
Messaging
REST

81. Shop Admin
(vert.x)
Delivery
(Spring)
WebShop
(Akka)
Merchant
(ratpack.io)
ADs
(Rx…)
Stats
(Spray)
DB

82. Shop Admin
(vert.x)
Data Flow
Backpressure
Delivery
(Spring)
WebShop
(Akka)
Merchant
(ratpack.io)
ADs
(Rx…)
Stats
(Spray)
DB

83. Example Akka

84. Example Akka

85. val display = {
def ellipse (i: Input) = setColor(i).fillOval(i(3), i(4), i(5), i(6))
def rect (i: Input) = setColor(i).fillRect(i(3), i(4), i(5), i(6))
val logics: Seq[(Input) => Unit] = Seq(ellipse, rect)
def rnd = Random.nextInt(255)
val timer = Source(0.seconds, 1.second, () => rnd )
val randoms = Source { () => Some(rnd) }
val functions = timer map { i => logics(i % logics.size) }
val display = functions map { f =>
val groups = randoms.take(7)
val params = groups.fold(List.empty[Int])((l, i) => i :: l)
for { p <- params } f(p)
}
display
}
def start = {
display.runWith(BlackholeSink)
}
Example Akka

86. Use Case
Price Correction
System

87. Product schedules
Competitors
Volatile sources
Audit
Historical trends
Alerts
Sales Heuristics
Pricing Rules
Adjustments

88. Competitors
Volatile sources
Audit
Historical trends
Alerts
Sales Heuristics
Pricing Rules
Adjustments
Timer Scheduler

89. Volatile sources
Audit
Historical trends
Alerts
Sales Heuristics
Pricing Rules
Adjustments
Timer Scheduler Robots

90. Audit
Historical trends
Alerts
Sales Heuristics
Pricing Rules
Adjustments
Validators
Timer Scheduler Robots

91. Historical trends
Alerts
Sales Heuristics
Pricing Rules
Adjustments
ValidatorsLogger
Timer Scheduler Robots

92. Historical trends
Alerts
Pricing Rules
Adjustments
Stock ValidatorsLogger
Timer Scheduler Robots

93. Historical trends
Alerts
Adjustments
Stock ValidatorsLogger
Timer Scheduler Robots
Pricing

94. Historical trends
Alerts
Stock ValidatorsLogger
Timer Scheduler Robots
Pricing Ruler

95. Historical trends
Stock ValidatorsLogger
Timer Scheduler Robots
Pricing Ruler Safety

96. Stock ValidatorsLogger
Timer Scheduler Robots
Pricing Ruler Safety
Archive

97. Stock
Validators
Logger
Timer Scheduler
Robots
Pricing
RulerSafety
Archive
Data Flow
Backpressure

98. val schedules = Flow[Date] mapConcat generateSchedules
val robots = Flow[Schedule] map scrape
val validations = Flow[ScrapeResult] map { site =>
logSite(site)
validate(site)
}
val pricing = Flow[Validation] map checkPrice
val stock = Flow[Validation] map checkStock
val ruler = Flow[(Price, Stock)] map applyRule
val safety = Flow[Rule] map checkSafety
val zip = Zip[Price, Stock]
val split = Broadcast[Validation]

99. Stock
Validators
Logger
Timer Scheduler
Robots
Pricing
RulerSafety
Archive
Data Flow
Backpressure

100. val timer = Source(0.seconds, 1.minute, () => now)
val archive = ForeachSink[SafetyCheck] { logRule }
val graph = FlowGraph { implicit builder =>
timer ~> schedules ~> robots ~> validations ~> split
split ~> stock ~> zip.right
split ~> pricing ~> zip.left ~> ruler ~> safety ~> archive
}
graph.run()

101. 24 cores
48 Gb
24 cores
48 Gb
150 000 000
positions
daily

102. Reactive Streams

103. Reactive Streams
•Simplify reactive programming
•Rise program’s abstraction level
•May be future JDK standard

104. Now I
care!

105. Thank you
https://github.com/slavaschmidt/reactive_streams_talk
@slavaschmidt
slavaschmidt@gmx.de