Transcription

1

2

3

4

5

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

10

11

12

13

14

15

16 Thread.setName( Bob );

17 String token = getgithubtoken("

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

19

20 Blink of an eye 100ms

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

22 String token = getgithubtoken("

23 =

24 #WRONG

25

26 Non Blocking For Everyone with Frank Lyaruu CTO Dexels

27 Non Blocking in Action 27

28 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

29 Writing non blocking code is rough 29

30 Servlet API 30

31 Non Blocking I/O Servlet API

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 = 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(); public void ondataavailable() throws IOException { while (input.isready()) { int read = input.read(buffer); output.write(buffer, 0, read); if (!output.isready()) return; } } public void onalldataread() throws IOException public void onwritepossible() throws IOException { if (input.isfinished()) { if (!complete) asynccontext.complete(); } else { ondataavailable(); } public void onerror(throwable failure) { failure.printstacktrace(); } } if (input.isfinished()) { complete = true; asynccontext.complete(); }

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() public void onwritepossible() throws IOException { while(out.isready()) { int len = file.read(buf); if(len<0) { return; } out.write(buf, 0, len); } } }); }

35 Bob 35

36 Developer 36

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 40 Reactive Programming Programming pipes

41 41 ReactiveX Polyglot RxJava RxScala RxJS RxPHP

42 42 Observable<T> 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));

45 RxJava Quick Intro Observable.range(0, 1000).skip(10).take(10).subscribe(item->System.err.println(item));

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 RxJava Quick Intro 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)); }

49 Reactive API s 49

50 A Blocking API public static Double temperatureincity(string city) { return Double.parseDouble(HTTPClient.get(" } For consumers: Double temperature = temperatureincity("tripoli");

51 Convert to Reactive public Observable<Double> temperatureincity(string city) { return Observable.just( Double.parseDouble(HTTPClient.get(" )); }

52

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(" }

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(" }

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 59 Back pressure 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 61 Back pressure! 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 63 Back pressure Operation

64 64 Back pressure Operation

65 65 Memory Consumption! Much better! or much worse

66 66 Error Handling! 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"/> 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 </cities>

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

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

70 70 Conclusions! 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 Dexels dexels.com Please rate!