Kotlin from scratch 3 - Coroutines

What is a Coroutine in Kotlin? Which are the differences with threads? What is collaborative concurrency? Have a look at these slides and at the companion Github repository https://github.com/f-lombardo/kotlin-from-scratch

Transcript

1. Kotlin from scratch 3 franco.lombardo@smeup.com - https://www.linkedin.com/in/francolombardo/ Coroutines
2. Danger zone!!! Photo by Vladyslav Cherkasenko on Unsplash
3. See the example project https://github.com/f-lombardo/kotlin-from-scratch
4. What is a thread? A thread is the smallest sequence of programmed instructions that can be managed independently by the operating system scheduler. (Wikipedia) fun main(args: Array<String>) { thread(start = true, name = "Calandrino", isDaemon = true) { while(true) { logMsg("So' bischero!") BigInteger.probablePrime(3072, Random()) } } Thread { while(true) { logMsg("Io pitto!") BigInteger.probablePrime(3072, Random()) } }.apply { name = "Buffalmacco" }.start() }
5. Threads are operating system objects At least on *nix systems!
6. Threads are operating system objects And on IBM i / AS400! (WRKJVMJOB command)
7. What is a coroutine? Coroutines generalize subroutines for non-preemptive multitasking, by allowing execution to be suspended and resumed. Coroutines are very similar to threads. However, coroutines are cooperatively multitasked, whereas threads are typically preemptively multitasked. This means that coroutines provide concurrency but not parallelism. (Wikipedia) Subroutines: objects defined by the programming language, not by the operating system.
8. Parallelism Photo by kakei lam on Unsplash
9. Parallelism Calandrino thread Calandrino’s computation Buffalmacco thread Buffalmaccos’s computation
10. Concurrency By Backlit - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=12225421
11. Concurrency Main thread Calandrino Buffalmacco Suspended coroutines Calandrino Buffalmacco
12. How to create a coroutine? 1) In build.gradle add the dependency to org.jetbrains.kotlinx:kotlinx-coroutines-core:version_nbr 2) There is a system property to set if you want to see more coroutine infos System.setProperty("kotlinx.coroutines.debug", "")
13. How to create a coroutine? fun main(args: Array<String>) = runBlocking { async(CoroutineName("Calandrino")) { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) } } async(CoroutineName("Buffalmacco")) { while (true) { logMsg("Io pitto!") BigInteger.probablePrime(1024, Random()) } } } runBlocking, async (and launch) are coroutines builders
14. It doesn’t work as expected! fun main(args: Array<String>) = runBlocking { async(CoroutineName("Calandrino")) { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) } } async(CoroutineName("Buffalmacco")) { while (true) { logMsg("Io pitto!") BigInteger.probablePrime(1024, Random()) } } } It just prints “So’ bischero!”
15. Remember: we have to collaborate! fun main(args: Array<String>) = runBlocking { async(CoroutineName("Calandrino")) { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) yield() } } async(CoroutineName("Buffalmacco")) { while (true) { logMsg("Io pitto!") BigInteger.probablePrime(1024, Random()) yield() } } } yield gives control to other coroutines
16. How to collaborate? yield gives control to other coroutines
17. How to collaborate? delay is like Thread.sleep
18. Collaborating using delay fun main(args: Array<String>) = runBlocking { async(CoroutineName("Calandrino")) { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) delay(10) } } async(CoroutineName("Buffalmacco")) { while (true) { logMsg("Io pitto!") BigInteger.probablePrime(1024, Random()) delay(10) } } }
19. await waits for another coroutine to complete How to collaborate?
20. Collaborating using await fun main(args: Array<String>) { runBlocking { async(CoroutineName("Calandrino")) { while (true) { val deferredNumber: Deferred<BigInteger> = async { bigPrime() } logMsg("Bischerata numero ${deferredNumber.await()}") } } async(CoroutineName("Buffalmacco")) { while (true) { val deferredNumber: Deferred<BigInteger> = async { bigPrime() } logMsg("Clandrino è bischero ${deferredNumber.await()} volte!") } } } }
21. Collaborating using await fun main(args: Array<String>) { runBlocking { async(CoroutineName("Calandrino")) { while (true) { logMsg("Bischerata numero ${bigPrime()}") } } async(CoroutineName("Buffalmacco")) { while (true) { logMsg("Calandrino è bischero ${bigPrime()} volte!") } } } } It doesn’t work because Calandrino keeps the thread!
22. Collaborating using await fun main(args: Array<String>) { runBlocking { async(CoroutineName("Calandrino")) { while (true) { logMsg("Bischerata numero ${bigPrime()}") } } async(CoroutineName("Buffalmacco")) { while (true) { logMsg("Calandrino è bischero ${bigPrime()} volte!") } } } } It doesn’t work because Calandrino keeps the thread! (Bischero!)
23. suspend fun calandrinate() { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) yield() } } async(CoroutineName("Calandrino")) { calandrinate() } Collaborating functions are suspending ones async(CoroutineName("Calandrino")) { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) yield() } }
24. suspend fun calandrinate() { while (true) { logMsg("So' bischero!") BigInteger.probablePrime(1024, Random()) yield() } } Collaborating functions are suspending ones The suspend modifier does not make a function either asynchronous or non-blocking. It just tells that the function could be suspended, as it could call other suspending functions (such as yield or delay). Anyway, it’s a good convention to create suspending functions that don’t block the calling thread.
25. async and launch builders need a scope! CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) } The async and launch coroutines builders are extension functions for the CoroutineScope interface, so they must be called on an object of that type. When you see them called without an explicit scope, as inside runBlocking, it is because they are called in a block that provides an implicit this receiver of type CoroutineScope.
26. async and launch builders need a scope! CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) } A CoroutineScope holds information on how to run coroutines, using a CoroutineContext object. We can create one of them with: • the CoroutineScope factory function; • the MainScope factory function: this works for Android, Swing and JavaFx applications, pointing to the Main UI thread; • the GlobalScope object, for top-level coroutines which are operating on the whole application lifetime; • the runBlocking function, that creates an implicit CoroutinesScope receiver; • the coroutineScope function (inside a suspend function/coroutine).
27. async and launch builders need a scope! CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) } A CoroutineContext is something like a “set” of properties related to the coroutine. Each element of a CoroutineContext is a CoroutineContext too. Elements can be added with the + operator. So, whenever we have a CoroutineContext parameter, we can pass just one type of information, that will override the existing one, or a concatenated set of elements.
28. async and launch builders need a scope! Whenever we have a CoroutineContext parameter, we can pass just one type of information, that will override the existing one, or a concatenated set of elements. The type of these three expression is CoroutineContext: • Dispatchers.Unconfined • CoroutineName("Calandrino") • Dispatchers.Unconfined + CoroutineName("Calandrino") CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) }
29. async and launch builders need a scope! CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) } An important type of CoroutineContext element is the Dispatcher, that defines the thread running the coroutine.
30. async and launch builders need a scope! CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) } Types of dispatchers: • Dispatcher.Default: backed by a shared pool of threads with maximum size equal to the number of CPU cores; for CPU/bound tasks; • Dispatcher.IO: for offloading blocking IO tasks to a shared pool of threads (the default is 64); • Dispatcher.Main: main UI thread in Android/Swing applications; • Dispathcer.Unconfined: not confined to any specific thread. The coroutine executes in the current thread first and lets the coroutine resume in whatever thread.
31. async and launch builders need a scope! CoroutineScope(Dispatchers.Unconfined + CoroutineName("Calandrino")).async { bigPrime(1024) } Dispatcher can also be created with these functions: • newSingleThreadContext: one thread per coroutine; • newFixedThreadPoolContex: a fixed size thread pool; • asCoroutineDispatcher extension function on Java Executor.
32. The launch builder fun main(args: Array<String>) = runBlocking { val job: Job = launch(Dispatchers.Unconfined) { ConsoleProgressBar().showContinuously() } println("A big prime number: ${bigPrime(2048)}") job.cancel() } The launch builder returns a Job that can be used to control the execution of the coroutine.
33. Parent-child hierarchies for Jobs Parent jobs wait the end of all their children Cancellation of a parent leads to immediate cancellation of all its children fun main(args: Array<String>) = runBlocking { val job: Job = launch(Dispatchers.Unconfined) { launch { launch { delayAndLog() } delayAndLog() } delayAndLog() } println("Here is a big prime number: ${bigPrime(2048)}") job.cancel() }
34. Why coroutines? (1..100_000).forEach { launch { while (true) delay(10_000) } }
35. Why coroutines? (1..10_000).forEach { thread(start = true) { while (true) Thread.sleep(10_000) } }
36. Why coroutines? (1..10_000).forEach { thread(start = true) { while (true) Thread.sleep(10_000) } } By the way: it works on Windows! J
37. Good reads Kotlin Coroutines in Android - Basics https://medium.com/swlh/kotlin-coroutines-in-android-basics-9904c98d4714 Concurrency is not parallelism https://kotlinexpertise.com/kotlin-coroutines-concurrency/ Blocking threads, suspending coroutines https://medium.com/@elizarov/blocking-threads-suspending-coroutines-d33e11bf4761 Coroutines: Suspending State Machines https://medium.com/google-developer-experts/coroutines-suspending-state-machines-36b189f8aa60 Coroutines hands-on https://play.kotlinlang.org/hands-on/Introduction%20to%20Coroutines%20and%20Channels/