RxJava2 thread safety

Transcript

1. RxJava2 thread safety operators and subjects
2. About me Nikita Nemtin Android/iOS developer nikita_nemtin@epam.com @nvnemtin
3. Multithreading Main thread IO thread Computation thread Time
4. Multithreading
5. Multithreading Deadlock Starvation No magic bullet
6. Multithreading Race Livelock …
7. Java Memory Model Reordering Visibility
8. How can you handle it? Language built-in means java.util.concurrent RxJava?
9. RxJava Not a magic bullet Race condition
10. Observable contract Observer Observable Subscribe OnNext; OnNext; OnNext… OnComplete / OnError
11. Observable contract Observer Observable Subscribe OnNext; OnNext; OnNext… OnComplete / OnError Happens-before
12. Happens-before
13. RxJava: async vs multithreading • RxJava is about asynchronous reactive programming
14. RxJava: async vs multithreading
15. Single thread
16. Multithreading
17. Async
18. Asynchrony Multithreading
19. Why RxJava is not thread safe? • Performance • Implementation complexity • Harder to maintain • Harder to reason about operators and the flows they combined to
25. RxJava: not tread safe operators • take(...) • scan(...) • distinct() • ....
26. distinct() operator
27. @Test fun `break distinct()`() { val numberOfThreads = 10 repeat(100000) { println("Iteration = $it") val actuallyReceived = AtomicInteger() val source = ObservableSource<Int> { observer -> val threads = mutableListOf<Thread>() val latch = CountDownLatch(numberOfThreads) (0 until numberOfThreads).forEach { threadNum -> threads.add( thread(start = false) { repeat(100) { observer.onNext(threadNum) } latch.countDown() } )
28. } latch.countDown() } ) } threads.forEach { thread -> thread.start() } latch.await() observer.onComplete() } Observable.defer<Int> { source } .distinct() .blockingSubscribe { actuallyReceived.incrementAndGet() } val got = actuallyReceived.get() assertTrue("got $got", actuallyReceived.get() == 10) } }
30. } latch.countDown() } ) } threads.forEach { thread -> thread.start() } latch.await() observer.onComplete() } Observable.defer<Int> { source } .serialize() .distinct() .blockingSubscribe { actuallyReceived.incrementAndGet() } val got = actuallyReceived.get() assertTrue("got $got", actuallyReceived.get() == 10) } }
32. Subjects • Observable & Observer • Convenient bridge between Rx world and common world
33. Subjects • Publish Subject • Behaviour Subject • Replay Subject • Async Subject
34. Subjects • Publish Subject • Behaviour Subject • Replay Subject • Async Subject • Serialized subject - the only thread safe.
35. @Test fun `break PublishSubject`() { val numberOfThreads = 10 repeat(100000) { println("Iteration = $it") val publishSubject = PublishSubject.create<Int>() val latch = CountDownLatch(numberOfThreads) val threads = mutableListOf<Thread>() val actuallyReceived = AtomicInteger() val counter = AtomicInteger() publishSubject .doOnNext { counter.incrementAndGet() } .doOnNext { counter.decrementAndGet() } .filter { counter.get() != 0 } .subscribe { actuallyReceived.incrementAndGet() }
36. .doOnNext { counter.incrementAndGet() } .doOnNext { counter.decrementAndGet() } .filter { counter.get() != 0 } .subscribe { actuallyReceived.incrementAndGet() } (0..numberOfThreads).forEach { threads += thread(start = false) { publishSubject.onNext(it) latch.countDown() } } threads.forEach { it.start() } latch.await() val got = actuallyReceived.get() assertTrue("got $got", actuallyReceived.get() == 0) } }
38. @Test fun `break PublishSubject`() { val numberOfThreads = 10 repeat(100000) { println("Iteration = $it") val publishSubject = PublishSubject.create<Int>().toSerialized() val latch = CountDownLatch(numberOfThreads) val threads = mutableListOf<Thread>() val actuallyReceived = AtomicInteger() val counter = AtomicInteger() publishSubject .doOnNext { counter.incrementAndGet() } .doOnNext { counter.decrementAndGet() } .filter { counter.get() != 0 } .subscribe { actuallyReceived.incrementAndGet() }
40. Root cause. serialize()
41. public void onNext(@NonNull T t) { if (done) { return; } if (t == null) { upstream.dispose(); onError(new NullPointerException("onNext called with… return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(QUEU… queue = q;
42. if (done) { return; } if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(QUEU… queue = q; } q.add(NotificationLite.next(t)); return; } emitting = true; } downstream.onNext(t); emitLoop(); }
43. return; } synchronized (this) { if (done) { return; } if (emitting) { AppendOnlyLinkedArrayList<Object> q = queue; if (q == null) { q = new AppendOnlyLinkedArrayList<Object>(QUEU… queue = q; } q.add(NotificationLite.next(t)); return; } emitting = true; } downstream.onNext(t);
44. void emitLoop() { for (;;) { AppendOnlyLinkedArrayList<Object> q; synchronized (this) { q = queue; if (q == null) { emitting = false; return; } queue = null; } if (q.accept(downstream)) { return; } } }
45. /* public */ final class SerializedSubject<T> extends Subject<… // Some code here /** * Constructor that wraps an actual subject. * @param actual the subject wrapped */ SerializedSubject(final Subject<T> actual) { this.actual = actual; }
46. Summarising the talk • Thread safety markers for rx operators:
47. Summarising the talk • Thread safety markers for rx operators: • it operates on several Observables
48. Summarising the talk • Thread safety markers for rx operators: • it operates on several Observables • it has a scheduler as a parameter
49. Summarising the talk • Thread safety quick sheet • Try not to use Observable.create(…)
50. Summarising the talk • Thread safety quick sheet • Try not to use Observable.create(…) • Remember about Observable contract and happens-before relation
51. Summarising the talk • Thread safety quick sheet • Try not to use Observable.create(…) • Remember about Observable contract and happens-before relation • Use serialize() and toSerialized()
52. Summarising the talk • Thread safety quick sheet • Try not to use Observable.create(…) • Remember about Observable contract and happens-before relation • Use serialize() and toSerialized() • Try not to extract state out of rx chain
53. Links • RxJava thread safety of operators and subjects artemzin.com/blog/rxjava-thread-safety-of-operators-and-subjects/ • Java memory model(ru) javaspecialist.ru/2011/06/java-memory-model.html • Bitbucket repo with this talk examples bitbucket.org/nvnemtin/rxjavatalk1/src/master/ • David Karnok's PublishSubject example stackoverflow.com/a/43265441 • Observable contract reactivex.io/documentation/contract.html
55. Graphics sources • multithreading https://makeagif.com/gif/multithreading-JloXT7 • synched https://tenor.com/view/pitstop-crew-f1-ferrari-gif-3530236 • race condition 1 https://g.redditmedia.com/KHaL_YWhyltzNfM1iNkxV8ZJZbpqnvKT_zc_eigPu-Q.gif? w=320&s=2487df64f830af9d8b5ba34d484d7a86 • reordering https://cs4.pikabu.ru/post_img/2016/01/11/8/1452514726180132199.gif • visibility http://suptg.thisisnotatrueending.com/archive/28369334/images/1385080733731.gif • race condition 2 https://www.reddit.com/r/ProgrammerHumor/comments/2skae8/ perfect_demonstration_of_a_race_condition/ • versus https://2ch.hk/b/src/191673522/15504925525871.png
56. Summarising the talk • Thread safety quick sheet • Try not to use Observable.create(…) • Remember about Observable contract and happens-before relation • Use serialize() and toSerialized() • Try not to extract state out of rx chain • Questions? nikita_nemtin@epam.com @nvnemtin