FlowOn for changing dispatcher in Kotlin - Step-by-Step Execution

Concept Flow - FlowOn for changing dispatcher

Start Flow

↓

Emit values on IO Dispatcher

↓

Apply flowOn(Dispatchers.IO)

↓

Switch context to IO Dispatcher

↓

Collect values on Default Dispatcher

↓

End Flow

flowOn switches the context to the IO dispatcher for upstream operations like emitting values, while collection happens on the Default dispatcher.

Execution Sample

Kotlin

flow {
    emit(1)
    emit(2)
}.flowOn(Dispatchers.IO).collect { value ->
    println("Collected $value on ${Thread.currentThread().name}")
}

This code emits two values in a flow on the IO dispatcher via flowOn, then collects and prints each value with the current thread name on the Default dispatcher.

Execution Table

Step	Action	Dispatcher/Thread	Value Emitted/Collected	Output
1	Start flow builder	Default dispatcher	-	-
2	Emit value 1	IO dispatcher	1	-
3	Switch context with flowOn	IO dispatcher	-	-
4	Collect value 1	Default dispatcher	1	Collected 1 on Default-thread
5	Emit value 2	IO dispatcher	2	-
6	Collect value 2	Default dispatcher	2	Collected 2 on Default-thread
7	Flow completes	Default dispatcher	-	-

💡 Flow completes after all values are emitted and collected with context switched by flowOn.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
value	-	1	1	2	2
dispatcher	Default	IO	Default	Default	Default

Key Moments - 2 Insights

Why does the collection happen on the default dispatcher and not the IO dispatcher?

Because flowOn changes the upstream context to IO dispatcher, so collection runs on the original Default dispatcher as shown in steps 4 and 6 of the execution_table.

Does flowOn change the dispatcher for the emit calls?

Yes, emit calls happen on the IO dispatcher as seen in steps 2 and 5; flowOn changes the upstream dispatcher for emit calls, while downstream operations like collect run on original.

Visual Quiz - 3 Questions

Look at the execution_table, on which dispatcher is the value 1 collected?

A Main dispatcher

B Default dispatcher

C IO dispatcher

D Unconfined dispatcher

💡 Hint

Check step 4 in the execution_table where collection happens on Default dispatcher.

At which step does the flow switch context to the IO dispatcher?

A Step 3

B Step 2

C Step 5

D Step 6

💡 Hint

Look at the 'Action' column in execution_table for flowOn context switch.

If flowOn was removed, where would collection happen?

A On Main dispatcher

B On IO dispatcher

C On Default dispatcher

D On Unconfined dispatcher

💡 Hint

Without flowOn, collection stays on the original dispatcher as shown by variable 'dispatcher' in variable_tracker.

Concept Snapshot

flowOn changes the dispatcher for upstream flow operations.
Emit runs on dispatcher set by flowOn.
Collect runs on original dispatcher.
Useful to switch context for heavy or IO tasks.
Syntax: flow.flowOn(Dispatchers.IO).collect { ... }

Full Transcript

This example shows how Kotlin Flow emits values on the IO dispatcher. When flowOn is applied with Dispatchers.IO, the upstream operations like emit run on the IO dispatcher. The execution table traces each step: starting the flow, emitting values on the IO dispatcher, switching context with flowOn, and collecting values on the Default dispatcher. Variables track the current value and dispatcher context. Key moments clarify that flowOn affects only upstream operations like emit calls, not downstream collect. The visual quiz tests understanding of dispatcher switching and flowOn behavior. The concept snapshot summarizes that flowOn changes the dispatcher for upstream flow operations, allowing context switching for tasks like IO.

Practice

1. What does the flowOn operator do in Kotlin Flow?

easy

A. It collects the flow on the main thread.

B. It changes the thread where the flow is executed.

C. It cancels the flow immediately.

D. It buffers the flow emissions.

Solution

1. Step 1: Understand the role of flowOn

   The flowOn operator changes the dispatcher where the upstream flow runs, allowing background work on a different thread.

2. Step 2: Differentiate from other flow operators

   Unlike collection which runs on the original coroutine context, flowOn switches the execution context of the flow itself.

3. Final Answer:

   It changes the thread where the flow is executed. -> Option B

4. Quick Check:

   flowOn switches thread = B [OK]

Hint: Remember: flowOn changes flow thread, not collector thread [OK]

Common Mistakes:

• Confusing flowOn with collect context
• Thinking flowOn cancels the flow
• Assuming flowOn buffers emissions

2. Which of the following is the correct syntax to apply flowOn to a flow named myFlow to run on Dispatchers.IO?

easy

A. myFlow.runOn(Dispatchers.IO)

B. myFlow.collectOn(Dispatchers.IO)

C. myFlow.flow(Dispatchers.IO)

D. myFlow.flowOn(Dispatchers.IO)

Solution

1. Step 1: Identify the correct function name

   The operator to change the dispatcher of a flow is flowOn, not collectOn, flow, or runOn.

2. Step 2: Confirm the syntax usage

   The correct syntax is calling flowOn on the flow instance with the dispatcher as argument.

3. Final Answer:

   myFlow.flowOn(Dispatchers.IO) -> Option D

4. Quick Check:

   Correct syntax = A [OK]

Hint: Use flowOn exactly as method name [OK]

Common Mistakes:

• Using wrong method names like collectOn
• Passing dispatcher incorrectly
• Confusing flowOn with collect

3. What will be the output thread of the collector in this code snippet?

flow {
  emit(Thread.currentThread().name)
}.flowOn(Dispatchers.IO)
 .collect { println(it) }

medium

A. The collector runs on the original coroutine context thread.

B. The collector runs on the main thread regardless.

C. The collector runs on Dispatchers.IO thread.

D. The collector runs on a new thread created by flowOn.

Solution

1. Step 1: Understand flowOn effect on upstream

   The flowOn(Dispatchers.IO) changes the thread where the flow builder runs, so emit runs on IO thread.

2. Step 2: Identify collector thread context

   The collector runs on the coroutine context where collect is called, which is the original coroutine context unless changed explicitly.

3. Final Answer:

   The collector runs on the original coroutine context thread. -> Option A

4. Quick Check:

   Collector thread = original context = C [OK]

Hint: flowOn changes upstream thread, collector stays on original [OK]

Common Mistakes:

• Assuming collector runs on flowOn dispatcher
• Thinking flowOn creates new thread for collector
• Confusing emit thread with collect thread

4. Identify the error in this Kotlin Flow code:

flow {
  emit(1)
}.flowOn(Dispatchers.IO)
.collect { value ->
  println(value)
}

medium

A. Missing coroutine scope to call collect.

B. flowOn cannot be used with emit.

C. collect must be called before flowOn.

D. Dispatchers.IO is not a valid dispatcher.

Solution

1. Step 1: Check coroutine context for collect

   The collect function is a suspend function and must be called inside a coroutine or suspend function.

2. Step 2: Verify flowOn and emit usage

   Using flowOn(Dispatchers.IO) with emit is correct; no error here.

3. Final Answer:

   Missing coroutine scope to call collect. -> Option A

4. Quick Check:

   collect needs coroutine scope = D [OK]

Hint: Always call collect inside coroutine or suspend function [OK]

Common Mistakes:

• Thinking flowOn can't be used with emit
• Calling collect outside coroutine
• Misordering flowOn and collect

5. You want to perform a CPU-intensive calculation inside a flow and collect results on the main thread. Which is the correct way to use flowOn and collect to achieve this?

hard

A. Use collectOn(Dispatchers.Default) for calculation and flowOn(Dispatchers.Main) for collection.

B. Use flowOn(Dispatchers.Main) for calculation and collect on Default dispatcher.

C. Use flowOn(Dispatchers.Default) for calculation and collect on main thread.

D. Run calculation and collection both on Dispatchers.IO.

Solution

1. Step 1: Choose dispatcher for CPU-intensive work

   CPU-intensive tasks should run on Dispatchers.Default to avoid blocking main thread.

2. Step 2: Use flowOn to switch flow execution thread

   Applying flowOn(Dispatchers.Default) runs the flow builder on Default dispatcher.

3. Step 3: Collect on main thread

   Collecting on main thread allows UI updates; no dispatcher change needed for collect.

4. Final Answer:

   Use flowOn(Dispatchers.Default) for calculation and collect on main thread. -> Option C

5. Quick Check:

   CPU work on Default, collect on main = A [OK]

Hint: Put heavy work in flowOn(Default), collect on main thread [OK]

Common Mistakes:

• Using flowOn(Main) for heavy work
• Confusing flowOn with collectOn
• Running CPU work on IO dispatcher