Threads, Main Thread & Kotlin Coroutines

1. Main Thread (UI Thread)

What: The main thread (also called the UI thread) is where Android executes UI-related tasks — drawing, event handling, and lifecycle methods.

Why: It ensures that all UI operations happen sequentially and safely, avoiding race conditions or UI corruption.

How: The main thread internally runs a Looper and MessageQueue. The Looper waits for tasks or messages in the queue and executes them one by one.

2. Example of Blocking the UI Thread

fun doAction(view: View) {
    executeLongRunningTask() // Blocks main thread
}

private fun executeLongRunningTask() {
    for (i in 1..1_000_000_000L) {
        // Long computation
    }
}

Effect: The UI freezes and may cause an Application Not Responding (ANR) error.

3. Fix Using a Background Thread

fun doAction(view: View) {
    Thread(start = true) {
        executeLongRunningTask()
    }
}

Why Not Ideal:

• Each thread consumes ~1–2 MB memory (OS-level resource).
• Context switching is expensive for the CPU.
• Managing threads manually can cause leaks and crashes.

4. Kotlin Coroutines

What: Lightweight, cooperative routines that can run multiple tasks on the same thread without blocking it.

Why: Threads are limited and costly; coroutines are managed by Kotlin runtime and can run thousands of tasks concurrently.

How: Coroutines suspend instead of blocking — when waiting, they yield control so other coroutines can run.

5. Coroutine Scope & Context

We need two things to run coroutine.

• Coroutine Scope: Defines the lifespan of a coroutine. It gets canceled automatically when its parent (Activity, Fragment, or ViewModel) is destroyed.
• Coroutine Context: Defines which thread (dispatcher) the coroutine runs on.

6. Dispatchers

What: A dispatcher decides which thread(s) a coroutine will use for its execution.

• Dispatchers.Main: Runs on the main/UI thread — for updating UI or lightweight operations.
• Dispatchers.IO: Optimized for I/O operations like network calls or database reads/writes.
• Dispatchers.Default: For CPU-intensive operations like sorting or calculations.

7. Example Using Dispatchers

fun doAction(view: View) {
    CoroutineScope(Dispatchers.IO).launch {
        Log.d(TAG, "Running on: ${Thread.currentThread().name}")
    }

    GlobalScope.launch(Dispatchers.Main) {
        Log.d(TAG, "Running on: ${Thread.currentThread().name}")
    }

    MainScope().launch(Dispatchers.Default) {
        Log.d(TAG, "Running on: ${Thread.currentThread().name}")
    }
}

8. Common Coroutine Scopes

• GlobalScope: Lifetime = entire app. Use rarely; can cause leaks.
• MainScope: Runs with Main dispatcher, often used for simple UI components.
• lifecycleScope: Automatically cancels coroutines when Activity/Fragment is destroyed.
• viewModelScope: Cancels coroutines when ViewModel is cleared.
• supervisorScope: Allows child coroutines to fail independently without canceling siblings.

9. Summary

• Avoid long-running tasks on the main thread.
• Use coroutines instead of raw threads for async work.
• Choose appropriate dispatchers for I/O, CPU, or UI tasks.
• Use structured scopes (lifecycleScope, viewModelScope) to prevent leaks.