How does the main thread work in Android?

The Main Thread in Android, also known as the UI Thread, is the only thread that:

• Handles all user interface events (button presses, scrolling).
• Renders elements on the screen.
• Executes the lifecycle code of components (Activity, Fragment).

When an Android application starts, it creates the main thread. All user interface components are created and updated only on this thread.

Key concepts:

• Event Loop: The main thread runs in a loop, constantly retrieving messages (UI events, rendering tasks) from the message queue (MessageQueue) and dispatching them to the appropriate handlers (Handler).
• Looper: The Looper object is associated with the thread and manages this message processing loop.
• Handler: The Handler object allows sending and processing Message objects and Runnables in the thread's MessageQueue where the Handler was created. Usually, a Handler is created on the main thread to interact with the UI from other threads.

Problems:

• ANR (Application Not Responding): If a long operation runs on the main thread, it gets blocked, does not process UI events, and does not render the screen. This leads to application freezing and an ANR dialog. The typical duration that causes ANR on the main thread when working with UI is 5 seconds.

Solution:

• Perform long operations (network requests, database work, complex calculations) in background threads.
• Use inter-thread communication mechanisms to update the UI from background threads (e.g., Handler, AsyncTask, Coroutines).

// Example of using Handler to update UI from a background thread
Handler mainHandler = new Handler(Looper.getMainLooper());

new Thread(new Runnable() {
    @Override
    public void run() {
        // Perform long operation in background thread
        // ...

        // Send task to update UI on the main thread
        mainHandler.post(new Runnable() {
            @Override
            public void run() {
                // Update UI on the main thread
                // ...
            }
        });
    }
}).start();

// Example of using coroutines to update UI from a background thread
import kotlinx.coroutines.*

fun fetchDataAndUpdateUI() {
    CoroutineScope(Dispatchers.IO).launch {
        // Perform long operation in background thread
        val data = fetchDataFromServer()

        // Switch context to main thread to update UI
        withContext(Dispatchers.Main) {
            updateUI(data)
        }
    }
}