Kotlin Coroutines

Introduction to coroutines in Kotlin
presented at MCE

Transcript

1. Svetlana Isakova @sveta_isakova Kotlin Coroutines
2. The Kotlin programming language • Releases: • Kotlin 1.0 - February 2016 • Kotlin 1.1 - March 2017 • Used in JetBrains • Used in Expedia, NBC News, Digital, Netflix, Amex, Pinterest, and others
3. Kotlin Coroutines • the key new feature in Kotlin 1.1 • brings the support of: • async/await, • yield, • and more
4. Coroutine a main routine and a subroutine vs coroutines, which call on each other • the term from 1960s • was used in “The Art of Computer Programming” by Donald Knuth
5. Agenda • motivation: async/await • threads & coroutines • common questions
6. Motivation: async/await
7. Motivation time consuming operation val image = loadImage(url) myUI.setImage(image)
8. Asynchronous computations time consuming operation callback loadImageAsync().whenComplete { image -> panel.setImage(image) }
9. Coroutines suspending call async { val image = loadImageAsync(url).await() myUI.setImage(image) }
10. loadImageAsync().whenComplete { image -> panel.setImage(image) } async { val image = loadImageAsync(url).await() myUI.setImage(image) }
11. C# way async Task<Image> LoadImageAsync(String url) { /* do the work */ } Kotlin way fun loadImageAsync() = async { /* do the work */ }
12. C# way async Task ProcessImage(String url) { var image = await LoadImage(url); myUI.SetImage(image); } Kotlin way fun processImage() = async { val image = loadImageAsync().await() myUI.setImage(image) }
13. coroutines async/await Language Library async/await - functions defined in the standard library
14. Threads & Coroutines
15. Asynchronous computations: how?
16. New thread for every computation too expensive
17. Executor • fixed number of threads • adding tasks • but: difficult to manage dependencies
18. Coroutine = “lightweight thread” computation that can be suspended
19. Coroutine = “lightweight thread” computation that can be suspended
20. suspend fun computation that can be suspended
21. Why suspend?
22. Blocking thread idle too expensive
23. thenCombine / zip CompletableFutures / Rx computation in a callback
24. 1 2 3 • computation that can be suspended • thread is not blocking! Coroutines
25. suspending call Back to image example fun loadImageAsync() = async { /* do the work */ } fun processImage() = async { val image = loadImageAsync().await() myUI.setImage(image) }
26. fun loadImageAsync(): Deferred<Image> = async { /* do the work */ } interface Deferred<out T> {
 suspend fun await(): T
 } await is a suspend function
27. fun processImage() = async { val image = loadImageAsync().await() myUI.setImage(image) } await suspends computation loadImageAsync processImage processImage loadImageAsync 1 2 await
28. await suspends computation loadImageAsync processImage 2 loadImageAsync processImage 3 …and continues it when result is ready On which thread?
29. Q: On which thread can the coroutine be continued? A: You specify that.
30. Continue in any thread from thread pool async(CommonPool) {
 ...
 } 1 2 3 3
31. Continue in the UI thread 1 2 3 launch(UI) { ... } UI UI UI
32. Custom executor launch(CustomContext) {
 ...
 } You can launch coroutine in the custom executor
33. fun processImage() = async(UI) {
 val deferred = loadImageAsync()
 // do other work
 val image = deferred.await() showImage(image)
 } Suspension might not happen if the result is already available processImage loadImageAsync await 1 2 processImage loadImageAsync
34. fun overlay(first: Image, second: Image): Image fun overlayAsync() = async(CommonPool) {
 val first = loadImageAsync("green")
 val second = loadImageAsync("red")
 overlay(first.await(), second.await())
 } Image overlay: two asynchronous computations
35. fun overlayAsync() = async(CommonPool) {
 val first = loadImageAsync("green")
 val second = loadImageAsync("red")
 overlay(first.await(), second.await())
 } button.onClick {
 launch(UI) {
 val image = overlayAsync().await()
 showImage(image)
 }
 } Image overlay
36. Common questions
37. Q: What about handling errors (exceptions)? A: await rethrows the exception, so regular try/catch works.
38. await rethrows exceptions val task = async(CommonPool) { ...
 throw MyException()
 }
 try {
 task.await()
 } catch (e: MyException) {
 ...
 } 1 3 throw e catch (e) 2
39. Q: Can I cancel the coroutine? A: Yes (if coroutine is cancellable).
40. val job = async(CommonPool) {
 while (isActive) {
 ...
 }
 }
 job.cancel() Check cancellation explicitly in computation code
41. Library suspend functions like await, delay check for cancellation val job = async(CommonPool) {
 delay(1000)
 task.await()
 }
 job.cancel()
42. You can run the code without cancellation val job = launch(CommonPool) { try { ... } finally { run(NonCancellable) { // this code isn't cancelled } } } job.cancel()
43. Q: Can I define my custom suspend functions? A: Yes.
44. suspend fun login(login: String): UserID
 
 suspend fun loadUserData(userID: UserID): UserData
 
 suspend fun loadImage(id: String): Image Functions that can be suspended
45. suspend fun showUserInfo(name: String) {
 val userID = login(name)
 val data = loadUserData(userID)
 val image = async(CommonPool) {
 loadImage(userData.imageID)
 }
 launch(UI) {
 showData(data)
 showImage(image.await())
 }
 } Using suspend functions
46. Q: Where can I call suspend functions? A: Inside other suspend functions and inside async/launch (in fact: inside suspend lambdas).
47. fun launch( context: CoroutineContext, block: suspend CoroutineScope.() -> Unit ): Job fun <T> async( context: CoroutineContext, block: suspend CoroutineScope.() -> T ) : Deferred<T> suspend lambdas
48. Implementation details
49. suspend fun foo(): Int suspend fun foo(continuation: Continuation<Int>): Int Hidden parameter: continuation
50. suspend fun foo(): Int fun fooAsync(): CompletableFuture<Int> = future { foo() } fun fooAsync(): Single<Int> = rxSingle(CommonPool) { foo() } To call suspend foo from Java wrap it into fooAsync if you have Java 8 if you have RxJava
51. Coroutine body is compiled to a state machine 1 2 3 4 … state 1 state 2
52. Bonus: yield
53. fun load(s: String) = run { println("loading $s"); s } val seq = buildSequence { yield(load("first")) yield(load("second")) } for (s in seq) { println("processing $s") } loading first processing first loading second processing second yield when required
54. coroutines async/await Language Library channels actors kotlinx.coroutines yield
55. kotlinx.coroutines • https://github.com/Kotlin/kotlinx.coroutines/ • Guide to kotlinx.coroutines by example • by Roman Elizarov (@relizarov)
57. Have a nice Kotlin!