This document discusses reactive programming approaches to handling timeouts, cancellations, and retries for asynchronous operations. It describes how traditional imperative approaches using blocking calls can lead to issues. Reactive programming offers non-blocking alternatives using Mono, Flux, and operators like timeout, retryWhen, and flatMap that allow composing asynchronous operations while managing timeouts, cancellations and retries in a way that is reusable and prevents callback hell. Specific examples are provided for handling timeouts on individual requests or whole processes, as well as retrying requests with exponential backoff while maintaining a global timeout.

1. September 2–3, 2020
Springone.Io
1
🤨
RETRY
TIMEOUTS&CANCEL,
✋♻⌛KeepYour Sanity Thanks to Reactive Programming

2. The Infamous
Request-Response

3. The Infamous
Request-Response
In an Imperative Blocking World

4. Response result = makeRequest();

5. 🙂🖥 🌎
5
❓

6. 🙂🖥 🌎
6
🤖
❓

7. 🙂🖥 🌎
7
🤖
❓
🤨

8. 😒🖥 🌎
8
⏱ 🤖
❗

9. 😠🖥 🌎
9
🤖
❗
⏱

10. 😡🖥 🌎
10
🤖
❗

11. 😡🖥 🌎
11
❗

12. Once you've made the request,
you're blocked waiting for the response
12

13. Demo

14. Going
Asynchronous

15. Future<Response> future = makeRequest();

16. 🙂🖥 🌎
16
❓

17. 🙂🖥 🌎
17
🤖
❓

18. 🙂🖥 🌎
18
🤖
❓

19. 🙂🖥 🌎
🤖
❓
19
🤨

20. 🙂🖥 🌎
20
🤖
❓
🤨✋

21. With an asynchronous call
you can cancel
21

22. Future<Response> future = makeRequest();

23. Future<Response> future = makeRequest();
future.cancel();

24. Demo

25. What if the Request
Is More Complex?

26. What if the Request
Is More Complex?
Sequence of Multiple Calls

27. CompletableFuture<List<String>> fids = findIds();
List<String> ids = fids.get();
CompletableFuture<Response> nextResult;
for (String id : ids) {
nextResult = makeRequest(id);
if (userCancelled) {
nextResult.cancel(true);
}
}

28. CompletableFuture<List<String>> fids = findIds();
List<String> ids = fids.get();
CompletableFuture<Response> nextResult;
for (String id : ids) {
nextResult = makeRequest(id);
if (userCancelled) {
nextResult.cancel(true);
}
}

29. 🙂🖥 🌎
29
❓

30. 🙂🖥 🌎
30
🤖
❓

31. 🙂🖥 🌎
31
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

32. 🙂🖥 🌎
32
🤨
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

33. 🙂🖥 🌎
33
🤨
✋ 🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

34. 🙂🖥 🌎
34
🤨
✋
🤖
❓
🤖
❓
🤖
❓
🤖
❓

35. 😒🖥 🌎
35
✋
🤖
❓
🤖
❓
🤖
❓

36. 😠🖥 🌎
36
✋
🤖
❓
🤖
❓

37. 😡🖥 🌎
37
✋
🤖
❓

38. cancelling gets more complex
38

39. (yes, that code can be further composed into
a single CompletableFuture)
39

40. Enter Reactive
Programming
This Looks Like a Perfect Case for Mono

41. Mono<List<Value>> results = findIds() //Flux<String>

42. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id)) //Flux<Response>

43. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r)) //Flux<Value>

44. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList(); //Mono<List<Value>>

45. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results.subscribe();

46. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results.subscribe();
d.dispose();

47. 🙂🖥 🌎
47
❓

48. 🙂🖥 🌎
48
🤖
❓

49. 🙂🖥 🌎
49
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

50. 🙂🖥 🌎
50
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

51. 🙂🖥 🌎
51
🤨
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

52. 🙂🖥 🌎
52
🤨
✋ 🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓

53. 😁🖥 🌎
53

54. Demo

55. A Word About
Timeouts
Classic Solutions

56. Classic Solution 1
provide a maximum duration
56

57. //budget=5s
makeRequest(uri, 5, TimeUnit.SECONDS);

58. Passing a maximum duration
doesn't compose and lacks abstraction
58

59. Passing a maximum duration
is often too fine grained to be useful to users
59

60. eg. timeout on an inner request
vs the whole user interaction
60

61. //budget=5s
long timeout = 5;
TimeUnit unit = TimeUnit.SECONDS;
//what if each of these can take up to 5s??
makeRequest(uri1, timeout, unit);
makeRequest(uri2, timeout, unit);
file.write(timeout, unit);

62. Classic Solution 2
passing a deadline around
62

63. //budget=5s
makeRequest(uri,2020-01-01T20:30:02.123);

64. //budget=5s
//each of these are constrained by same deadline
makeRequest(uri1, 2020-01-01T20:30:02.123);
makeRequest(uri2, 2020-01-01T20:30:02.123);
file.write(2020-01-01T20:30:02.123);

65. Passing a deadline around
composes well BUT...
65

66. Passing a deadline around
composes well BUT...
66

67. Passing a deadline around
composes well but
67
leaks in the API

68. Passing a deadline around
composes well but
68
forces the effort on the user

69. i.e. boilerplate conversion and
passing around of deadline
at every level
69

70. //budget=5s
//extracting these into a method...
makeRequest(uri1, 2020-01-01T20:30:02.123);
makeRequest(uri2, 2020-01-01T20:30:02.123);
file.write(2020-01-01T20:30:02.123);

71. //...deadline concept leaks into the API
void process(ZonedDateTime deadline) {
makeRequest(uri1, deadline);
makeRequest(uri2, deadline);
file.write(deadline);
}
//thus it is up to the user to compute deadline
ZonedDateTime deadline = ZonedDateTime
.now()
.plus(Duration.ofSeconds(5));

72. Passing a deadline around
is thus less practical
72

73. Enter Reactive
Programming
This Looks Like a Perfect Case for Timeout Operator

74. Mono<Void> process = makeRequest(uri1)
.then(makeRequest(uri2))
.then(writeFile());
Disposable d = process
.subscribe();

75. Mono<Void> process = makeRequest(uri1)
.then(makeRequest(uri2))
.then(writeFile());
Disposable d = process
.timeout(Duration.ofSeconds(5))
.subscribe();

76. Mono<Void> process = makeRequest(uri1)
.then(makeRequest(uri2))
.then(writeFile());
Disposable d = process
.timeout(Duration.ofSeconds(5))
.subscribe();
timeout on
the whole

77. Mono<Void> process = makeRequest(uri1)
.then(makeRequest(uri2))
.then(writeFile());
Disposable d = process
.timeout(Duration.ofSeconds(5))
.subscribe();
still manually
cancellable

78. Ease of use with Duration,
yet composable and fine grained
78

79. back to Mono<List<Value>> example
79

80. Mono<List<Value>> results = findIds()
.flatMap(id ->
makeRequest(id)
).map(r -> extractBody(r)).collectList();
Disposable d = results
.subscribe();

81. Mono<List<Value>> results = findIds()
.flatMap(id ->
makeRequest(id)
).map(r -> extractBody(r)).collectList();
Disposable d = results
.timeout(Duration.ofSeconds(5))
.subscribe();
add timeout on
the whole operation

82. Mono<List<Value>> results = findIds()
.flatMap(id ->
makeRequest(id)
.timeout(Duration.ofSeconds(1))
).map(r -> extractBody(r)).collectList();
Disposable d = results
.timeout(Duration.ofSeconds(5))
.subscribe();
each inner request
has own timeout
add timeout on
the whole operation

83. 🙂🖥 🌎
83
❓

84. 🙂🖥 🌎
84
❓
🤖⏳

85. 🙂🖥 🌎
85
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓
⏳

86. 🙂🖥 🌎
86
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓
⏳

87. 🙂🖥 🌎
87
🤖
❓
🤖
❓
🤖
❓
🤖
❓
🤖
❓
⏳⏳
⌛⌛❗

88. 🙂🖥 🌎
88
⌛❗

89. 🙂🖥 🌎
89
⌛❗

90. 🙃🖥 🌎
90
⌛❗

91. Demo

92. And if I Want To
Retry?

93. Retry on what?
93

94. eg. remote failures?
94

95. What if I want to
combine with timeouts?
95

96. And can I keep the whole thing
cancellable?
96

97. AND apply an exponential backoff?
97

98. Just Combine
ONE MORE
Operator!
This Looks Like a Perfect Case for retryWhen Operator

99. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

100. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

101. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

102. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

103. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

104. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

105. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();

106. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();
retry
on remote
errors only

107. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();
still manually
cancellable
still timeout on
the whole

108. Position matters
108

109. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.timeout(Duration.ofSeconds(5))
.subscribe();
retries
with a global
timeout

110. Mono<List<Value>> results = findIds()
.flatMap(id -> makeRequest(id))
.map(r -> extractBody(r))
.collectList();
Disposable d = results
.timeout(Duration.ofSeconds(5))
.retryWhen(backoff(5, Duration.ofMillis(10))
.maxBackoff(Duration.ofSeconds(1))
.jitter(0.4))
.subscribe();
vs timeout
on each
attempt

111. Demo

112. THANKS👍

113. Questions❓Join the Virtual Hallway Room To Chat
@SimonBasle
@ProjectReactor