Об эволюции потоков Java c JDK 6 до наших дней, движущих силах этой эволюции и венце творения - Reactive Streams

1. Reactive
Streams

2. Reactive
Streams
THEN
Java Developer
LATER
Enterprise
Architect
NOW
Scala Consultant
TWITTER
@slavaschmidt
MAIL
slavaschmidt@gmx.de

3. Stream

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

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

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 PipedInputStream B
protected byte buffer[];

27. Java IO
A PipedOutputStream PipedInputStream B
Write
Block
Transfer
Block
Read
Block

28. Java IO
val alice = new SThread("RS-Alice") {
override def swap(n: Int) {
val out = new PipedOutputStream()
val in = new PipedInputStream(out, size)
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()
}
}

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

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

31. Java IO
val alice = new SThread("RS-Alice") {
override def swap(n: Int) {
val out = new PipedOutputStream()
val in = new PipedInputStream(out, size)
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()
}
}
INCREASE

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

33. Java NIO
“There is a better way”

34. Java NIO
A Buffer SinkChannel SourceChannel Buffer
B
Write
Block
Transfer
Read
Block
Read
Fill

35. Java NIO
val 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 pipe = Pipe.open()
val sinkChannel = pipe.sink
val sourceChannel = pipe.source
sourceChannel.configureBlocking(true)
sinkChannel.configureBlocking(false)
BLOCKING
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)
}
}

36. Java NIO
val 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 pipe = Pipe.open()
val sinkChannel = pipe.sink
val sourceChannel = pipe.source
sourceChannel.configureBlocking(false)
sinkChannel.configureBlocking(false)
NON-BLOCKING
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)
}
}

37. Java NIO
“Choose how to fail”

38. IO & NIO

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

40. Solution
Backpressure

41. Solution
Backpressure
Dynamic Push/Pull
Fast Boris

42. Solution
Backpressure
Dynamic Push/Pull
Fast Alice

43. Backpressure
A Stream B
Demand
Data
Demand
Data

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 Scalable
Terminates on error

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

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

51. Responsive
Elastic Resilient
Message Driven

52. Reactive
Responsive
Elastic Resilient
Message Driven
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
Producer Subscriber
subscribe
Subscription
onSubscribe

58. Streaming
request
Subscription
onNext
onComplete
onError
cancel
Subscriber

59. Publisher
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)
}
}

60. Subscriber
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)
}
}

61. Right Subscriber
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)
}
}

62. 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)
}
}
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)
}
}

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

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

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

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

67. Vert.X
//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()

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
ADs Stats
Delivery
WebShop
Merchant

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

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

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

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

83. Example Akka

84. Example Akka

85. Example Akka
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)
}

86. Use Case
Price Correction
System

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

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

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

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

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

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

93. Timer Scheduler Robots
Stock Logger Validators
Pricing
Historical trends
Alerts
Adjustments

94. Timer Scheduler Robots
Stock Logger Validators
Historical trends
Alerts
Pricing Ruler

95. Timer Scheduler Robots
Stock Logger Validators
Pricing Ruler Safety
Historical trends

96. Timer Scheduler Robots
Stock Logger Validators
Pricing Ruler Safety
Archive

97. Timer Scheduler
Validators
Stock
Logger
Robots
Pricing
Archive
Safety Ruler
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. Timer Scheduler
Validators
Stock
Logger
Robots
Pricing
Archive
Safety Ruler
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
@slavaschmidt
slavaschmidt@gmx.de