Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Waiting for Godot

Waiting for Godot

This talk gives an introduction to Kotlin coroutines. You can find the samples in this GitHub repo: https://github.com/tkuenneth/mind_the_thread

Thomas Künneth

January 20, 2021
Tweet

More Decks by Thomas Künneth

Other Decks in Technology

Transcript

  1. https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#terminology A coroutine is an instance of [a] suspendable computation.

    It is conceptually similar to a thread, in the sense that it takes a block of code to run and has a similar life-cycle — it is created and started, but it is not bound to any particular thread. It may suspend its execution in one thread and resume in another one. Moreover, like a future or promise, it may complete with some result (which is either a value or an exception).
  2. TL;DR; § Coroutines can be suspended and resumed § Are

    like lightweight threads § Kotlin somehow uses threads for their execution Matt Walsh, Unsplash (https://unsplash.com/photos/tVkdGtEe2C4)
  3. CoroutineScope § Controls and manages one or more coroutines §

    Can start and cancel them § Is notified upon cancellations and failures § Defines when/where/how long coroutines exist Coroutine Builder Coroutine Context Coroutine Scope { ... }
  4. § Usually a scope corresponds to the lifecycle of some

    entity § Coroutine-aware frameworks provide specific scopes § GlobalScope is valid during lifetime of the app
  5. CoroutineContext § Each coroutine is executed in a specific context

    (CoroutineContext) § Is provided through CoroutineScope.coroutineContext § Implemented as an index based set of elements (mixture of a set and a map) Coroutine Builder Coroutine Context Coroutine Scope { ... }
  6. § A new coroutine inherits the parent context § parent

    context = Defaults + inherited context + arguments (for example from launch) § new CoroutineContext = parent context + Job() § Important elements: CoroutineDispatcher, Job, CoroutineExceptionHandler, CoroutineName
  7. Coroutine Dispatcher § Define which threads are used to execute

    a coroutine § Can confine a coroutine to one thread, a thread pool, or pose no restrictions
  8. § Dispatchers.Default execution in a thread pool based on the

    number of cores § Dispatchers.Main Execution only on the Main Thread § Dispatchers.IO For long running/blocking I/O operations § Dispatchers.Unconfined no restrictions (shouldn‘t be used)
  9. https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#terminology A coroutine builder [is] a function that takes some

    suspending lambda as an argument, creates a coroutine, and, optionally, gives access to its result in some form. For example, launch{}, future{}, and sequence{} [..] are coroutine builders. The standard library provides primitive coroutine builders that are used to define all other coroutine builders. Coroutine Builder Coroutine Context Coroutine Scope { ... }
  10. Coroutine Builder: TL;DR; § launch coroutines § examples: launch, async,

    runBlocking, ... § extension functions to CoroutineScope § Can receive parameters, for example a launch mode Matt Walsh, Unsplash (https://unsplash.com/photos/tVkdGtEe2C4)
  11. Launch modes § DEFAULT begin execution immediately § ATOMIC similar

    to DEFAULT; can be cancelled only after execution has started § LAZY launch only if needed (when result is accessed) § UNDISPATCHED Immediate execution on the current thread
  12. A suspending lambda [is a] a block of code that

    have to run in a coroutine. It looks exactly like an ordinary lambda expression but its functional type is marked with suspend modifier. Just like a regular lambda expression is a short syntactic form for an anonymous local function, a suspending lambda is a short syntactic form for an anonymous suspending function. It may suspend execution of the code without blocking the current thread of execution by invoking suspending functions. For example, blocks of code in curly braces following launch, future, and sequence functions [...] are suspending lambdas. https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#terminology
  13. A suspending function is a function that is marked with

    suspend modifier. It may suspend execution of the code without blocking the current thread of execution by invoking other suspending functions. A suspending function cannot be invoked from a regular code, but only from other suspending functions and from suspending lambdas [...]. For example, await() and yield() [...] are suspending functions that may be defined in a library. The standard library provides primitive suspending functions that are used to define all other suspending functions. https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#terminology
  14. https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md#terminology A suspension point is a point during coroutine execution

    where the execution of the coroutine may be suspended. Syntactically, a suspension point is an invocation of suspending function, but the actual suspension happens when the suspending function invokes the standard library primitive to suspend the execution. A continuation is a state of the suspended coroutine at suspension point. It conceptually represents the rest of its execution after the suspension point.
  15. TL;DR; § suspend functions are basic building blocks of coroutines

    § are paused at some time or have to wait for something to finish § do not block the current thread § are called from other coroutines or suspending functions § like normal functions return something Matt Walsh, Unsplash (https://unsplash.com/photos/tVkdGtEe2C4 Matt Walsh, Unsplash (https://unsplash.com/photos/tVkdGtEe2C4)
  16. § runBlocking and coroutineScope wait for the execution of its

    block and children § runBlocking blocks the current thread § coroutineScope suspends its execution § Difference: coroutine builder vs. suspending function
  17. Cancel execution § launch returns a Job instance § controls

    the lifecycle § allows for hierarchies § cancel initiates the cancellation § join waits for the cancellation to take effect
  18. § Cancelling a scope with cancel() cancels all children §

    Cancelling a child with cancel() does not cancel other children
  19. § Detect cancellation requests with isActive § Regularly invoke delay(),

    yield() or ensureActive() ... val job = launch { println("Enter") var count = 0 while (isActive) { println("${++count}") yield() } println("Exit") } ... • All suspending functions in kotlinx.coroutines are cancellable • Your suspend functions should be cancellable, too
  20. CancellationException § Is thrown by suspend functions to signal a

    cancellation § Useful to distinguish between cancellations and other exceptions
  21. Deferred § launch is fire and forget § What if

    somethig should be done when a result is available? § Deferred is a non blocking, cancellable Future § Created with async (Builder) or CompletableDeferred() § Same states like Job § Get result with await() (in case of an error an exception is thrown)
  22. § Exceptions after launch are treated like uncaught exceptions in

    threads § Crashed children cancel the parent with this exception § Exceptions should be be handeled explicitly when using async
  23. SupervisorJob § Errors or cancellations do not terminate other children:

    val scope = CoroutineScope(SupervisorJob()) § Uncaught exceptions are propagated upward § SupervisorJob works only when being the immediate parent of a coroutine
  24. § Coroutines look like threads § But behave differently §

    Blocking vs. suspending § Require cooperation