Skip to main content
Mapagam

Working with Kotlin Coroutines

1. Understanding Coroutine Basics

Kotlin Coroutines are a powerful feature for handling asynchronous operations in a more readable and maintainable way than traditional callbacks or threads.

Concept Description Usage
Coroutine A lightweight thread that can be suspended and resumed launch { ... }
Suspend Function A function that can be paused and resumed at a later point suspend fun fetchData(): String
Dispatcher Defines where the coroutine runs (main, IO, Default) Dispatchers.Main, Dispatchers.IO

Example: Basic Coroutine Usage

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        delay(1000)
        println("Hello from coroutine!")
    }
    Thread.sleep(2000) // Wait for coroutine to finish
}
Note: Coroutines must be launched within a CoroutineScope. Using GlobalScope is generally discouraged in production code due to potential memory leaks.

Key Points

  • Coroutines are lightweight and managed by the Kotlin runtime.
  • Suspend functions allow for non-blocking asynchronous code.
  • Dispatchers control where coroutines execute (e.g., Dispatchers.Main for UI updates).

2. Using Dispatchers

Dispatcher Description Use Case
Dispatchers.Main Runs on the main thread, suitable for UI updates Updating UI elements, handling user interactions
Dispatchers.IO Optimized for IO operations (network, disk) Fetching data from API, reading/writing files
Dispatchers.Default For CPU-intensive tasks Processing large datasets, computations
Dispatchers.Unconfined Runs on the calling thread without confinement When you want to avoid switching threads

Example: Using Dispatchers.IO for Network Call

import kotlinx.coroutines.*

suspend fun fetchUserData(userId: String): User {
    return withContext(Dispatchers.IO) {
        // Simulate network call
        delay(1000)
        User("John Doe", "john@example.com")
    }
}

Example: Switching Dispatchers

import kotlinx.coroutines.*

fun fetchData() {
    val scope = CoroutineScope(Dispatchers.Main)
    
    scope.launch {
        // Running on Main thread
        val user = fetchUserData("123")
        updateUI(user) // Safe to update UI here
        
        // Switch to IO dispatcher for network
        val data = withContext(Dispatchers.IO) {
            fetchDataFromNetwork()
        }
        
        // Back to Main for UI update
        updateUI(data)
    }
}

3. Implementing Suspend Functions

Property Description Example
suspend fun Defines a function that can be suspended and resumed later 
suspend fun fetchUserData(): User {
    delay(1000)
    return User("John", "john@example.com")
}
suspend Keyword indicating function can be suspended suspend fun delay(ms: Long) { ... }
CoroutineScope Provides context for launching coroutines val scope = CoroutineScope(Dispatchers.Main)

Example: Basic suspend function usage

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000)
    return "Data fetched"
}

fun main() {
    runBlocking {
        val result = fetchData()
        println(result)
    }
}

Example: Suspend function with exception handling

suspend fun riskyOperation(): String {
    delay(500)
    if (Math.random() > 0.5) {
        throw Exception("Something went wrong")
    }
    return "Success"
}

fun main() {
    runBlocking {
        try {
            val result = riskyOperation()
            println(result)
        } catch (e: Exception) {
            println("Caught exception: ${e.message}")
        }
    }
}

4. Using CoroutineScope

Property Description Usage
CoroutineScope Interface defining the scope of coroutines val scope = CoroutineScope(Dispatchers.Main)
launch Starts a new coroutine without blocking the caller scope.launch { delay(1000); println("Hello") }
async Starts a new coroutine and returns a Deferred result val deferred = scope.async { fetchData() }

Example: Creating and Using CoroutineScope

import kotlinx.coroutines.*

fun main() {
    val scope = CoroutineScope(Dispatchers.Main)
    
    scope.launch {
        delay(1000)
        println("Coroutine executed on Main dispatcher")
    }
    
    // Keep main thread alive for coroutine to finish
    Thread.sleep(2000)
}

Example: Using GlobalScope

import kotlinx.coroutines.*

fun main() {
    // GlobalScope is a predefined scope
    GlobalScope.launch {
        delay(1000)
        println("Running in GlobalScope")
    }
    
    Thread.sleep(2000)
}
Note: GlobalScope.launch runs the coroutine in a background thread and does not block the main thread.
Warning: Be cautious with GlobalScope as it does not cancel when the parent scope is cancelled.

5. Handling Coroutine Exceptions

Exception Type Description Handling Strategy
CancellationException Thrown when a coroutine is cancelled Use try...catch or supervisorScope to handle gracefully
InterruptedException Thrown when a thread is interrupted during coroutine execution Wrap in try...catch and rethrow if needed
IllegalStateException Occurs when coroutine state is invalid for operation Ensure proper lifecycle management and state checks

Example: Catching Exceptions in Coroutines

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000)
    if (Math.random() < 0.5) throw IOException("Network error")
    return "Data"
}

fun main() {
    val scope = CoroutineScope(Dispatchers.Main)
    scope.launch {
        try {
            val data = fetchData()
            println("Fetched: $data")
        } catch (e: IOException) {
            println("Caught IO exception: ${e.message}")
        } catch (e: Exception) {
            println("Caught generic exception: ${e.message}")
        }
    }
}

Example: Using SupervisorScope for Exception Isolation

import kotlinx.coroutines.*

fun main() {
    val scope = CoroutineScope(Dispatchers.Main)
    scope.launch {
        supervisorScope {
            launch {
                delay(1000)
                throw RuntimeException("Child coroutine failed")
            }
            launch {
                delay(2000)
                println("This will still run")
            }
        }
    }
}
Note: supervisorScope ensures that failure of one coroutine does not cancel others within the same scope.

Exception Handling Best Practices

  • Always wrap potentially failing coroutines in try...catch
  • Use supervisorScope to isolate exceptions between related coroutines
  • Handle specific exception types before generic ones
  • Log exceptions for debugging but don't expose sensitive data

6. Using Flow for Streams

Flow is a cold asynchronous stream in Kotlin that can emit multiple values over time. It's ideal for handling streams of data such as user input, network responses, or database changes.

Property Description Example
Flow<T> Represents a stream of values of type T val numbers: Flow<Int> = flowOf(1, 2, 3)
emit() Emits a value to the stream emit(42)
collect() Collects values from the flow numbers.collect { println(it) }

Example: Basic Flow Usage

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

fun main() {
    val numbers = flowOf(1, 2, 3, 4, 5)

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

Example: Flow with emit()

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

fun main() {
    val delayedNumbers = flow {
        for (i in 1..3) {
            delay(1000)
            emit(i * 10)
        }
    }

    runBlocking {
        delayedNumbers.collect { value ->
            println("Delayed: $value")
        }
    }
}
Note: Flow is cold, meaning it only starts emitting values when collected.

Key Features of Flow

  • Cold: Emission only happens when collected.
  • Lazy: Values are emitted on-demand.
  • Composable: Can be transformed using operators like map, filter.
  • Asynchronous: Supports concurrent operations with flatMap.

7. Transforming Flows

Flows in Kotlin can be transformed using various operators to modify, filter, or combine the data they emit. These transformations are performed lazily and are part of the flow's cold nature.

Operator Description Example
map Transforms each element emitted by the flow using a provided function. 
val numbers = flowOf(1, 2, 3)
    .map { it * 2 }
    .collect { println(it) } // Outputs: 2, 4, 6
filter Filters elements based on a predicate function. 
val numbers = flowOf(1, 2, 3, 4, 5)
    .filter { it % 2 == 0 }
    .collect { println(it) } // Outputs: 2, 4
flatMapConcat Transforms each element into a flow and concatenates them sequentially. 
val numbers = flowOf(1, 2)
    .flatMapConcat { 
        flowOf(it, it * 2) 
    }
    .collect { println(it) } // Outputs: 1, 2, 2, 4
flatMapMerge Transforms each element into a flow and merges them concurrently. 
val numbers = flowOf(1, 2)
    .flatMapMerge { 
        flowOf(it, it * 2) 
    }
    .collect { println(it) } // Outputs: 1, 2, 2, 4 (order may vary)
take Emits only the first n elements of the flow. 
val numbers = flowOf(1, 2, 3, 4, 5)
    .take(3)
    .collect { println(it) } // Outputs: 1, 2, 3
distinctUntilChanged Emits only elements that are different from the previous one. 
val numbers = flowOf(1, 1, 2, 2, 3)
    .distinctUntilChanged()
    .collect { println(it) } // Outputs: 1, 2, 3
Note: Transforming flows is a fundamental concept in Kotlin Coroutines, enabling efficient handling of asynchronous data streams.

8. Combining Flows

Operator Description Example
merge Merges multiple flows into one, emitting values as they arrive from any of the flows 
val flow1 = flowOf(1, 2)
val flow2 = flowOf(3, 4)
val merged = merge(flow1, flow2).collect { println(it) } // 1, 2, 3, 4
zip Combines values from two flows into a pair, emitting when both have a new value 
val flow1 = flowOf(1, 2)
val flow2 = flowOf("a", "b")
val zipped = zip(flow1, flow2) { a, b -> "$a$b" }
zipped.collect { println(it) } // "1a", "2b"
combine Combines values from multiple flows into a single value using a transform function 
val flow1 = flowOf(1, 2)
val flow2 = flowOf("a", "b")
val combined = combine(flow1, flow2) { a, b -> "$a$b" }
combined.collect { println(it) } // "1a", "2b"
flatMapMerge Flattens a flow of flows into a single flow, merging emissions 
val outer = flowOf(
    flowOf(1, 2),
    flowOf(3, 4)
)
val flattened = outer.flatMapMerge { it }
flattened.collect { println(it) } // 1, 2, 3, 4
Note: merge and flatMapMerge are useful for concurrent processing, while zip and combine are useful for synchronized emissions.

9. Working with StateFlow and SharedFlow

Feature Description Usage
StateFlow Immutable, emits the latest value and subsequent values to new collectors val stateFlow = MutableStateFlow("initial")
SharedFlow Emits values to multiple collectors, can be replayed or not val sharedFlow = MutableSharedFlow<String>()

Example: Using StateFlow

import kotlinx.coroutines.flow.*

class ViewModel {
    private val _state = MutableStateFlow("loading")
    val state: StateFlow<String> = _state.asStateFlow()

    fun updateState(newState: String) {
        _state.value = newState
    }
}

Example: Using SharedFlow

import kotlinx.coroutines.flow.*

class ViewModel {
    private val _events = MutableSharedFlow<String>()
    val events: SharedFlow<String> = _events.asSharedFlow()

    fun sendEvent(event: String) {
        _events.tryEmit(event)
    }
}

Key Differences

  • StateFlow: Always emits the latest value to new collectors
  • SharedFlow: Can replay values or not, supports multiple collectors

10. Using Channel for Communication

Channels in Kotlin are a powerful way to handle asynchronous communication between coroutines. They allow you to send and receive data in a thread-safe manner.

Channel Type Description Usage Example
Channel<T> Basic channel interface for sending and receiving values 
val channel = Channel<String>()
channel.send("Hello")
val message = channel.receive()
BufferedChannel<T> Channel with a buffer that can hold multiple values 
val channel = Channel<Int>(capacity = 10)
channel.send(42)
BroadcastChannel<T> Allows multiple consumers to receive the same values 
val channel = BroadcastChannel<String>(10)
channel.openSubscription().receive()

Example: Producer-Consumer Pattern

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() {
    runBlocking {
        val channel = Channel<Int>()
        
        // Producer
        launch {
            for (i in 1..5) {
                channel.send(i)
                delay(100)
            }
            channel.close()
        }
        
        // Consumer
        launch {
            for (value in channel) {
                println("Received: $value")
            }
        }
    }
}

Example: Using BroadcastChannel

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() {
    runBlocking {
        val broadcastChannel = BroadcastChannel<String>(10)
        
        // Multiple consumers
        launch {
            val subscription = broadcastChannel.openSubscription()
            for (message in subscription) {
                println("Consumer 1: $message")
            }
        }
        
        launch {
            val subscription = broadcastChannel.openSubscription()
            for (message in subscription) {
                println("Consumer 2: $message")
            }
        }
        
        // Producer
        launch {
            broadcastChannel.send("Hello!")
            broadcastChannel.close()
        }
    }
}
Note: Channels are send and receive operations are suspending, meaning they will suspend the coroutine until the operation completes.
Warning: Always close channels when done to prevent resource leaks.

Key Points

  • Channels provide a way to communicate between coroutines asynchronously.
  • Buffered channels can hold multiple values before blocking.
  • Broadcast channels allow multiple consumers to receive the same values.
  • Always close() channels to prevent resource leaks.

11. Implementing Deferred Results

Property Description Example
Deferred<T> Represents a computation that will complete at some point in the future val deferred: Deferred<String> = async { fetchData() }
await() Waits for the deferred result and returns it val result = deferred.await()
start() Starts the coroutine with the given start mode val deferred = async(start = CoroutineStart.LAZY) { ... }

Example: Using Deferred to Fetch Data

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000)
    return "Fetched Data"
}

fun main() = runBlocking {
    val deferred: Deferred<String> = async {
        fetchData()
    }

    println("Doing other work...")
    val result = deferred.await()
    println("Result: $result")
}

Example: Handling Deferred with Timeout

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred: Deferred<String> = async {
        delay(3000)
        "Delayed Result"
    }

    try {
        val result = withTimeout(1000) {
            deferred.await()
        }
    } catch (e: TimeoutCancellationException) {
        println("Deferred took too long")
    }
}

12. Cancelling Coroutines

Method Description Notes
Job.cancel() Requests cancellation of the coroutine Does not immediately stop the coroutine, but signals it to cancel
Job.cancelAndJoin() Cancels the coroutine and waits for its completion Blocks until the coroutine finishes cancellation
CoroutineScope.cancel() Cancels all coroutines in the scope Useful for cleaning up resources when a parent coroutine is cancelled

Example: Canceling a Coroutine

import kotlinx.coroutines.*

fun main() {
    val scope = CoroutineScope(Dispatchers.Default)
    val job = scope.launch {
        repeat(1000) { i ->
            println("Working... $i")
            delay(500)
        }
    }

    // Cancel the coroutine after 1 second
    scope.launch {
        delay(1000)
        job.cancel()
        println("Coroutine cancelled")
    }
}
Note: Cancellation is cooperative. Coroutines must be designed to respond to cancellation signals for it to work effectively.

Was this article helpful?

Related Cheat Sheets