Asynchronous Programming: Journey from RxJava to Kotlin Coroutines

Transcript

1. Idorenyin Obong Software engineer @Busha Guest author @Auth0, @CometChat
2. ASYNCHRONOUS PROGRAMMING The Journey from RxJava to Kotlin Coroutines
3. What is asynchronous programming?
4. SOLUTIONS • Threading
5. SOLUTIONS • Threading • Callbacks
6. SOLUTIONS • Threading • Callbacks • Futures/Promises
7. SOLUTIONS • Threading • Callbacks • Futures/Promises • Rx
8. RxJava • Event processing library
9. RxJava • Event processing library • It solves our asynchronous problem
10. Problems with RxJava
11. Problems with RxJava • Performance overhead
12. Problems with RxJava • Performance overhead • Learning complexity
13. SOLUTIONS • Threading • Callbacks • Futures/Promises • Rx • The future
14. “One can think of a coroutine as a light- weight thread. Like threads, coroutines can run in parallel, wait for each other and communicate. The biggest difference is that coroutines are very cheap, almost free: we can create thousands of them, and pay very little in terms of performance. True threads, on the other hand, are expensive to start and keep around. A thousand threads can be a serious challenge for a modern machine.” COROUTINES
15. “A coroutine is a way to handle concurrency tasks in a thread. It will run until stopped, and the thread will change the context to each coroutine without creating new threads.” COROUTINES
16. Why you should use Coroutines
17. Why you should use Coroutines • Clean sequential code
18. “Rx code is readable, however we still pass callbacks which doesn’t represent our mind model (we think sequentially)”
19. Why you should use Coroutines • Clean sequential code • Handles backpressure
20. Why you should use Coroutines • Clean sequential code • Handles backpressure • Third-party libraries support
21. Why you should use Coroutines • Clean sequential code • Handles backpressure • Third-party libraries support • Easier to create custom operators
22. Why you should use Coroutines • Clean sequential code • Handles backpressure • Third-party libraries support • Easier to create custom operators • More performant.
23. Why you should use Coroutines • Clean sequential code • Handles backpressure • Third-party libraries support • Easier to create custom operators • More performant. • Easier to learn
24. Migrating from RxJava to Coroutines
25. Network calls with Retrofit
26. @GET("/positions.json?description=web")
 fun getWebJobs(@Query("page") page: Int): Single<List<JobModel>> 
 private val disposables = CompositeDisposable()
 private val observer = object: DisposableSingleObserver<List<JobModel>>() {
 override fun onSuccess(t: List<JobModel>) {}
 override fun onError(e: Throwable) {}
 } 
 fetchWebJobs()
 .subscribeOn(Schedulers.io())
 .observeOn(AndroidSchedulers.mainThread())
 .subscribeWith<DisposableSingleObserver<List<JobModel>>>(observer)
 .addTo(disposables)
27. @GET("/positions.json?description=web")
 suspend fun getWebJobs(@Query("page") page: Int): List<JobModel> viewModelScope.launch {
 val result = ApiClient.client.getWebJobs(1)
 }
28. Dispatchers vs Schedulers
29. RxJava Schedulers • Schedulers.io
30. RxJava Schedulers • Schedulers.io • Schedulers.computation
31. RxJava Schedulers • Schedulers.io • Schedulers.computation • AndroidSchedulers.mainThread()
32. Coroutines Dispatchers • Dispatchers.IO
33. Coroutines Dispatchers • Dispatchers.IO • Dispatchers.Default
34. Coroutines Dispatchers • Dispatchers.IO • Dispatchers.Default • Dispatchers.Main
35. Coroutines Rx extension library
36. - Schedulers.asCoroutineDispatcher - Job.asCompletable - Deffered.asSingle
37. Best practices when using Coroutines
38. Best practices when using Coroutines • Try to avoid GlobalScope
39. GlobalScope.launch {
 // blocking call
 } AVOID
40. viewModelScope.launch {
 // blocking call
 } lifecycleScope.launch {
 // blocking call
 } RECOMMEND
41. Best practices when using Coroutines • Try to avoid GlobalScope • Try to avoid the async coroutine
42. val task = async(bgDispatcher) { 
 // blocking call
 } AVOID
43. 
 val result = withContext(bgDispatcher) { 
 // blocking call
 } RECOMMEND
44. Best practices when using Coroutines • Try to avoid GlobalScope • Try to avoid the async coroutine • Use the Dispatchers.Main as main coroutine
45. val uiScope = CoroutineScope(Dispatchers.Main)
 val bgDispatcher = Dispatchers.IO bgDispatcher.launch { 
 
 withContext(uiScope){ 
 // update UI
 }
 
 val result = // blocking call 
 
 withContext(uiScope){ 
 // update UI
 } } AVOID
46. val uiScope = CoroutineScope(Dispatchers.Main)
 val bgDispatcher = Dispatchers.IO uiScope.launch { 
 // updating UI
 
 val result = withContext(bgDispatcher){ 
 // blocking call
 }
 
 // update UI } RECOMMEND
47. Best practices when using Coroutines • Try to avoid GlobalScope • Try to avoid the async coroutine • Use the Dispatchers.Main as main coroutine • Always handle exceptions
48. Any questions? Gracias!