To raised perceive flows, we have to assessment sleep capabilities and coroutines.

A droop perform is just a function that may be paused and resumed at a later time. How does he try this? The compiler is doing the magic right here. The compiler merely takes code that appears procedural and turns it into callbacks below the hood. The continuation is the item that tracks the place to pause and the place to renew.

Suppose we’ve the next code that has 2 droop factors.

val a = a()
val y = foo(a).await() // suspension level #1
b()
val z = bar(a, y).await() // suspension level #2
c(z)

That is what the compiler generates internally. There are three states for this block of code:

• preliminary (earlier than any suspension level)
• after the primary suspension level
• after the second suspension level

class <anonymous_for_state_machine> extends SuspendLambda<...> 
// The present state of the state machine
int label = 0
// native variables of the coroutine
A a = null
Y y = null
void resumeWith(Object consequence) 
if (label == 0) goto L0
if (label == 1) goto L1
if (label == 2) goto L2
else throw IllegalStateException()
L0:
// result's anticipated to be `null` at this invocation
a = a()
label = 1
consequence = foo(a).await(this) // 'this' is handed as a continuation 
if (consequence == COROUTINE_SUSPENDED) return // return if await had suspended execution
L1:
// exterior code has resumed this coroutine passing the results of .await() 
y = (Y) consequence
b()
label = 2
consequence = bar(a, y).await(this) // 'this' is handed as a continuation
if (consequence == COROUTINE_SUSPENDED) return // return if await had suspended execution
L2:
// exterior code has resumed this coroutine passing the results of .await()
Z z = (Z) consequence
c(z)
label = -1 // No extra steps are allowed
return
          

The continuation object tracks the state of the droop perform. It updates the label as we transfer from one suspension level to a different. In different phrases, the compiler generates code that tracks the state of the sleep perform at completely different sleep factors.

The Coroutine context determines on which thread the coroutines will probably be executed. There are 4 choices:

• Dispatchers.Default – for CPU intensive work (eg sorting a big record)
• Dispatchers.Foremost – this can depend upon what you will have added to your packages runtime dependencies (for instance, kotlinx-coroutines-androidfor the UI thread in Android)
• Dispatchers.Unconfined – run limitless routines on a selected thread
• Dispatchers.IO – for I/O heavy work (for instance lengthy working database queries)

Coroutine Scope is a solution to hold monitor of all of the routines working in it. Every routine have to be executed in a scope. Structured concurrency in Kotlin Coroutines requires that builders all the time launch coroutines within the context of CoroutineScope or to specify a scope explicitly.

A coroutine is often launched utilizing launch routine builder:

enjoyable CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
// …
): Job

It’s outlined as an extension perform in CoroutineScope and take a CoroutineContext as a parameter, so it truly takes two coroutine contexts (since a scope is only a reference to a context). What does he do with them? It merges them utilizing the plus operator, producing a union of the set of their components.

A stream is used to symbolize a sequential difficulty of securities that sooner or later ends (as a result of naturally it ends or one thing dangerous occurs).

All operations in a Movement are executed sequentially inside the identical code block (and thus the identical Coroutine scope).

Behind the scenes, a stream is simply an interface that exposes a technique to gather the emitted values:

enjoyable interface FlowCollector<T> 
droop enjoyable emit(worth: T)
interface Movement<T> 
droop enjoyable acquire(collector: FlowCollector<T>)

These are merely 2 strategies which are marked droop and The stream and collector are simply perform calls that work collectively.

If we have a look at the compiled code, we’ll discover that it merely makes use of the droop perform to create a continuation object that marks how each the stream and the collector work collectively.

makes use of the sleep perform to create compiled code that’s mainly sequential in nature and scope to manage the move lifecycle.

Sources:

https://kt.academy/article/how-flow-works