SharedFlow for event broadcasting in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this SharedFlow example?

Consider this Kotlin code using MutableSharedFlow to broadcast events. What will be printed?

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val sharedFlow = MutableSharedFlow<Int>()

    launch {
        sharedFlow.collect { value ->
            println("Collector 1 received: $value")
        }
    }

    launch {
        delay(100)
        sharedFlow.emit(1)
        sharedFlow.emit(2)
    }

    launch {
        delay(200)
        sharedFlow.collect { value ->
            println("Collector 2 received: $value")
        }
    }

    delay(500)
}

A

Collector 1 received: 1
Collector 1 received: 2

B

Collector 1 received: 1
Collector 1 received: 2
Collector 2 received: 1
Collector 2 received: 2

C

Collector 1 received: 1
Collector 1 received: 2
Collector 2 received: 2

D

Collector 2 received: 1
Collector 2 received: 2

💡 Hint

Think about when Collector 2 starts collecting and what events it can receive.

Collector 1 starts immediately and receives both emitted values 1 and 2. Collector 2 starts collecting after a delay of 200ms, after both emissions around 100ms, so with replay=0 and no extra buffer, it receives nothing.

🧠 Conceptual

intermediate

What happens if replay is set to 1 in MutableSharedFlow?

In MutableSharedFlow(replay = 1), what does the replay parameter do?

A It limits the number of collectors to 1 at a time.

B It caches the last emitted value and replays it to new collectors when they start collecting.

C It buffers only one event and drops the rest if collectors are slow.

D It delays emission of events by 1 millisecond.

💡 Hint

Think about what replay means in the context of event streams.

The replay parameter controls how many past events are stored and sent to new collectors immediately upon subscription. Setting it to 1 means the last event is replayed to new subscribers.

🔧 Debug

advanced

Why does this SharedFlow code cause a deadlock?

Examine this Kotlin code snippet. Why does it cause the program to hang indefinitely?

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val sharedFlow = MutableSharedFlow<Int>(replay = 0, extraBufferCapacity = 0)

    launch {
        sharedFlow.emit(1)
        println("Emitted 1")
    }

    delay(100)

    sharedFlow.collect { value ->
        println("Collected: $value")
    }
}

A Because extraBufferCapacity is zero, causing a buffer overflow error.

B Because replay is zero, so no values are buffered and emit fails silently.

C Because emit suspends until there is a collector ready, but no collector is active when emit is called.

D Because collect is called after emit, so it misses all events and terminates immediately.

💡 Hint

Think about how emit behaves when there are no active collectors and no buffer.

With replay=0 and extraBufferCapacity=0, emit suspends until a collector is ready to receive the value. Since emit is called before collect, it waits forever, causing a deadlock.

📝 Syntax

advanced

Which option correctly creates a MutableSharedFlow with replay 2 and buffer capacity 3?

Choose the correct Kotlin code to create a MutableSharedFlow with replay = 2 and extraBufferCapacity = 3.

A val flow = MutableSharedFlow<Int>(replayCount = 2, bufferCapacity = 3)

B val flow = MutableSharedFlow<Int>(bufferCapacity = 3, replayCount = 2)

C val flow = MutableSharedFlow<Int>(replay = 3, extraBufferCapacity = 2)

D val flow = MutableSharedFlow<Int>(replay = 2, extraBufferCapacity = 3)

💡 Hint

Check the official parameter names for MutableSharedFlow constructor.

The correct parameter names are replay and extraBufferCapacity. Options A and B use wrong parameter names, and D swaps the values.

🚀 Application

expert

How to ensure all collectors receive all events in SharedFlow?

You want to broadcast events so that every collector receives all emitted events, even if they start collecting late. Which SharedFlow configuration achieves this?

A Use <code>MutableSharedFlow(replay = Int.MAX_VALUE)</code> to buffer all events indefinitely.

B Use <code>MutableSharedFlow(replay = 0, extraBufferCapacity = 0)</code> and start collectors before emitting.

C Use <code>MutableSharedFlow(replay = 1)</code> and emit events slowly to avoid loss.

D Use <code>MutableSharedFlow(replay = 0, extraBufferCapacity = Int.MAX_VALUE)</code> to buffer all events.

💡 Hint

Think about how replay buffers past events for new collectors.

Setting replay to a very large number buffers all emitted events so new collectors receive all past events. Other options either buffer nothing or rely on timing, which is unreliable.