Coroutines in Kotlin

# CHAPTER 23

Coroutines in Kotlin #

1. Chapter Introduction #

2. Learning Objectives #

• Understand the difference between OS Threads and Coroutines.

• Define and call suspend functions.

• Launch background tasks using GlobalScope.launch.

• Return data from background tasks using async and await.

• Use delay() to yield execution.

3. What is a Coroutine? #

*Note: Coroutines require an external library. In a Gradle project, you add org.jetbrains.kotlinx:kotlinx-coroutines-core.*

4. The launch Builder #

import kotlinx.coroutines.*

fun main() {
    println("Main thread started.")

    // Start a coroutine in the background
    GlobalScope.launch {
        delay(1000L) // Non-blocking sleep for 1 second!
        println("Hello from the Coroutine!")
    }

    println("Main thread is doing other work...")
    
    // We must sleep the main thread so it doesn't close before the coroutine finishes
    Thread.sleep(2000L) 
}

*Output:*

Main thread started.
Main thread is doing other work...
Hello from the Coroutine!

5. Suspend Functions #

// Mark the function with 'suspend'
suspend fun downloadData(): String {
    println("Downloading started...")
    delay(2000L) // Simulating a slow network
    return "Data Payload"
}

fun main() = runBlocking { 
    // runBlocking creates a coroutine that blocks the main thread until it finishes
    val result = downloadData()
    println(result)
}

6. async and await #

import kotlinx.coroutines.*

suspend fun fetchWeather(): String {
    delay(1000L)
    return "Sunny, 72F"
}

suspend fun fetchNews(): String {
    delay(1000L)
    return "Kotlin is awesome!"
}

fun main() = runBlocking {
    // Both start at the exact same time!
    val weatherDeferred = async { fetchWeather() }
    val newsDeferred = async { fetchNews() }

    // Wait for both to finish
    println("Weather: ${weatherDeferred.await()}")
    println("News: ${newsDeferred.await()}")
    
    // Total time is 1 second, not 2 seconds!
}

7. Mini Project: Async Task Runner #

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Starting App...")
    
    val job = launch {
        println("Task 1 running...")
        delay(500L)
        println("Task 1 complete.")
    }
    
    println("App UI is active...")
    
    job.join() // Waits specifically for this job to finish
    println("App Closing.")
}

8. Common Mistakes #

• Using Thread.sleep() inside a Coroutine: Thread.sleep blocks the actual OS thread, freezing everything. delay() suspends the coroutine, allowing the OS thread to execute other coroutines. Never use Thread.sleep inside a coroutine.

• Calling suspend functions from normal functions: The compiler will throw an error. A suspend function must be inside a launch, async, or runBlocking block.

9. Best Practices #

• Avoid GlobalScope: In production Android apps, never use GlobalScope.launch. If the user closes the app, a GlobalScope coroutine keeps running in the background, draining the battery! Use lifecycle-aware scopes like viewModelScope or lifecycleScope.

10. Exercises #

1. 1. Write a suspend fun calculateScore(): Int that delays for 2 seconds and returns 100.

1. 2. Inside fun main() = runBlocking, call it and print the result.

11. MCQs with Answers #

12. Interview Questions #

• Q: Contrast Coroutines with OS Threads. Why can you spawn 100,000 Coroutines but not 100,000 OS Threads?

• Q: Explain the difference between launch and async.

13. Summary #

14. Next Chapter Recommendation #