Intro to RxJava in a non blocking I/O context. My slides tend to make little sense without the talk ;-)

6. 8 - 24 minute delay

7. ± 30 min. round trip

8. Web
• DNS
• Redirect
• Download HTML
• Download CSS + JS + Images
• Download more CSS + JS + Images
• ….

9. Ordering a pizza
• Several hours per page
• About 8 pages per order

16. Thread.setName(“Bob”);

17. String token =
getGitHubToken("https://github.com/login",<params>);

18. • Connect TCP
• Encryption handshake
• Push request data through socket
• … wait …
• Pull data from the socket
• Assemble and return the result

20. Blink of an eye
100ms

21. Time
Network latency: milliseconds
Application instruction: microseconds
Hardware instructions: nanoseconds

22. String token =
getGitHubToken("https://github.com/login",<params>);

23. =

24. #WRONG

26. Non Blocking For Everyone
with RxJava
@lyaruu
Frank Lyaruu
CTO Dexels

27. Non Blocking in Action 27
https://webtide.com/async-rest

28. So why are we still writing blocking code?
! It works pretty well in monoliths
! CPU and memory is cheap
! Networks are reliable and fast
! Writing non blocking code is hard
28

29. Writing non blocking code is rough
29

30. Servlet API
30

31. Non Blocking I/O Servlet API 3.1
31

32. A Blocking Echo Servlet 32
public class BlockingServlet extends HttpServlet {
private static final int BUFFER_SIZE = 1024;
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
byte[] buffer = new byte[BUFFER_SIZE];
while (true) {
int read = request.getInputStream().read(buffer, 0, BUFFER_SIZE);
if (read < 0)
break;
response.getOutputStream().write(buffer, 0, read);
}
}
}

33. A Non Blocking Echo Servlet 33
public class NonBlockingServlet extends HttpServlet {
private static final int BUFFER_SIZE = 1024;
@Override
protected void service(HttpServletRequest request, HttpServletResponse
response) throws ServletException, IOException
{
AsyncContext asyncContext = request.startAsync(request, response);
asyncContext.setTimeout(0);
Echoer echoer = new Echoer(asyncContext);
request.getInputStream().setReadListener(echoer);
response.getOutputStream().setWriteListener(echoer);
}
private class Echoer implements ReadListener, WriteListener
{
private final byte[] buffer = new byte[BUFFER_SIZE];
private final AsyncContext asyncContext;
private final ServletInputStream input;
private final ServletOutputStream output;
private boolean complete;
private Echoer(AsyncContext asyncContext) throws IOException
{
this.asyncContext = asyncContext;
this.input = asyncContext.getRequest().getInputStream();
this.output = asyncContext.getResponse().getOutputStream();
}
@Override
public void onDataAvailable() throws IOException
{
while (input.isReady())
{
int read = input.read(buffer);
output.write(buffer, 0, read);
if (!output.isReady())
return;
}
if (input.isFinished())
{
complete = true;
asyncContext.complete();
}
}
@Override
public void onAllDataRead() throws IOException {}
@Override
public void onWritePossible() throws IOException
{
if (input.isFinished())
{
if (!complete)
asyncContext.complete();
}
else
{
onDataAvailable();
}
}
@Override
public void onError(Throwable failure)
{
failure.printStackTrace();
}
}
}

34. Maybe something simpler 34
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
AsyncContext asyncContext = request.startAsync(request, response);
final ServletOutputStream out = resp.getOutputStream();
final byte[] buf = new byte[1024];
final FileInputStream file = …;
out.setWriteListener(new WriteListener() {
@Override
public void onWritePossible() throws IOException {
while(out.isReady()) {
int len = file.read(buf);
if(len<0) {
return;
}
out.write(buf, 0, len);
}
}
});
}

35. 35
Bob

36. 36
Developer

37. Node.js 37
var server = http.createServer(function (req, res) {
req.pipe(res);
});

38. Node.js 38
var server = http.createServer(function (req, res) {
req.pipe(res);
});

39. A pipe… 39

40. Reactive Programming
40
Programming pipes

41. ReactiveX
41
Polyglot
RxJava RxScala RxJS RxPHP

42. Observable<T>
42
Will push zero or more items of type T
Followed by a ‘completed’ message
(or an error…)

43. RxJava Quick Intro 43
Observable.<String>just("Ouagadougou","Dakar","Accra","Rabat")
.subscribe(item->System.err.println(item));
Ouagadougou
Dakar
Accra
Rabat

44. RxJava Quick Intro 44
Observable.range(0, 1000)
.subscribe(item->System.err.println(item));
0
1
2
3
4
5
6
…
998
999

45. RxJava Quick Intro 45
Observable.range(0, 1000)
.skip(10)
.take(10)
.subscribe(item->System.err.println(item));
10
11
12
13
14
15
16
17
18
19

46. RxJava Quick Intro 46
Bytes.fromFile("citiesafrica.xml")
.lift(XML.parse())
.subscribe(item->System.err.println(item));
<cities>
<africa>
<city name="Lusaka"/>
<city name="Harare"/>
<city name="Kigali"/>
</africa>
</cities>
START_DOCUMENT
START_ELEMENT cities {}
START_ELEMENT africa {}
START_ELEMENT city {name=Lusaka}
END_ELEMENT city
START_ELEMENT city {name=Harare}
END_ELEMENT city
START_ELEMENT city {name=Kigali}
END_ELEMENT city
END_ELEMENT africa
END_ELEMENT cities
END_DOCUMENT

47. RxJava Quick Intro 47
Bytes.fromFile("citiesafrica.xml")
.lift(XML.parse())
.filter(e->e.getType()==XmlEventTypes.START_ELEMENT)
.map(e->e.getAttributes().get("name"))
.subscribe(item->System.err.println(item));
<cities>
<africa>
<city name="Lusaka"/>
<city name="Harare"/>
<city name="Kigali"/>
</africa>
</cities>
Lusaka
Harare
Kigali

48. static Observable<byte[]> createSourceObservable(HttpServletRequest req);
static Subscriber<byte[]> createSink(HttpServletResponse resp);
protected void doPost(HttpServletRequest req, final HttpServletResponse resp) {
createSourceObservable(req)
.subscribe(createSink(resp));
}
RxJava Quick Intro

49. Reactive API’s
49

50. A Blocking API
public static Double temperatureInCity(String city) {
return Double.parseDouble(HTTPClient
.get("http://api.weather.org/weather?q="+city)
.toXml()
.getContent("temperature"));
}
For consumers:
Double temperature = temperatureInCity("Tripoli");

51. Convert to Reactive
public Observable<Double> temperatureInCity(String city) {
return Observable.just(
Double.parseDouble(HTTPClient
.get("http://api.weather.org/weather?q="+city)
.toXml()
.getContent("temperature")
));
}

53. Sort of…
Double temp =
temperatureInCity(“Cairo”).blockingFirst();
updateTemperatureUI(temp);
This code is still just as blocking
But now the consumer and producer have independent
threading

54. Use a Non Blocking HTTP Client
public static Observable<Double> temperatureInCity(String city) {
return HTTP.get("http://api.weather.org/weather?q="+city)
.subscribeOn(Schedulers.io())
.lift(XML.parse())
.filter(e->e.getType()==XmlEventTypes.START_ELEMENT)
.filter(e->e.getText().equals("temperature"))
.first()
.map(xml->Double.parseDouble(xml.getAttributes().get("value")));
}

55. Add a Cache
public Observable<Double> temperatureInCity(String city) {
Double temperature = temperatureCache.get(city);
if(temperature!=null) {
return Observable.just(temperature);
}
return HTTP.get("http://api.weather.org/weather?q="+city)
.subscribeOn(Schedulers.io())
.lift(XML.parse())
.filter(e->e.getType()==XmlEventTypes.START_ELEMENT)
.filter(e->e.getText().equals("temperature"))
.first()
.map(xml->Double.parseDouble(xml.getAttributes().get("value")))
.doOnNext(temperature->temperatureCache.put(city,temperature));
}

56. Non Blocking Client
Blocking:
Double temp = temperatureInCity(“Cairo").toBlocking().first();
updateTemperatureUI(temp);
Non blocking:
temperatureInCity(“Nairobi”)
.observeOn(UISchedulers.uiThread())
.subscribe(d->updateTemperatureUI(d));

57. Challenges
57

58. Back pressure
58

59. Back pressure
59
Operation

60. A Blocking Echo Servlet 60
public class BlockingServlet extends HttpServlet {
private static final int BUFFER_SIZE = 1024;
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
byte[] buffer = new byte[BUFFER_SIZE];
while (true) {
int read = request.getInputStream().read(buffer, 0, BUFFER_SIZE);
if (read < 0)
break;
response.getOutputStream().write(buffer, 0, read);
}
}
}

61. Back pressure
61
! Observable: No back pressure
! Flowable: Back pressure

62. RxJava back pressure 62
Bytes.fromNetwork(“something_huge.xml”)
.lift(XML.parse())
.filter(e->e.getType()==XmlEventTypes.START_ELEMENT)
.map(e->e.getAttributes().get("name"))
.subscribe(item->doSomethingComplicated(item));

63. Back pressure
63
Operation

64. Back pressure
64
Operation

65. Memory Consumption
65
! Much better
! … or much worse

66. Error Handling
66
! Some patterns don’t work any more
! Requires some thought

67. Error handling 67
Servlet.handlePost()
.lift(XML.parse())
.subscribe(item->sendSomeWhere(item));
<cities>
<africa>
<city name="Lusaka"/>
<city name="Harare"/>
<city name="Kigali"/>
</cities>
START_DOCUMENT
START_ELEMENT cities {}
START_ELEMENT africa {}
START_ELEMENT city {name=Lusaka}
END_ELEMENT city
START_ELEMENT city {name=Harare}
END_ELEMENT city
START_ELEMENT city {name=Kigali}
END_ELEMENT city
END_ELEMENT africa
PARSE_ERROR

68. Non Blocking is not faster
68
! It is about utilising threads better
! If thread utilisation is not an issue, it
will perform similarly

69. Thoughts
69
! RxJava is lightweight and easy to add to existing
software
! Pleasant programming model
! Makes non blocking I/O bearable
! Can be used incrementally

70. Conclusions
70
! Threads are expensive
! Everything keeps getting faster except the speed of light
! Micro services
! Blocking code misbehaves under pressure
! The price of blocking communication will keep going up
I believe that, in time, some non blocking code is inevitable

71. Frank @Lyaruu dexels.com
Dexels frank@dexels.com
Please rate!