Android Handlers Thread And Runnable Complete Guide

Understanding Android Handlers, Threads, and Runnable

Threads in Android

In Android, threads are essential for performing operations that might take a long time, such as network operations or heavy computations, without blocking the main thread (UI thread). If the main thread is blocked, the application becomes unresponsive, and Android might display an "Application Not Responding" (ANR) dialog.

Key Concepts:

• Main Thread/ UI Thread: The thread where all UI components are drawn and updated. Blocking this thread results in a poor user experience.
• Worker Threads: These are threads other than the main thread, often used for background tasks like network operations or database transactions.
• Thread Safety: Not all UI components can be accessed from another thread; they must be accessed from the main thread to guarantee thread safety.

Creating a Thread: You can create a new Thread by extending the Thread class or implementing the Runnable interface.

// Extending Thread class
class MyThread extends Thread {
    @Override
    public void run() {
        // Your background code here
    }
}

// Using Runnable interface
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // Your background code here
    }
}

// Usage
new MyThread().start();
new Thread(new MyRunnable()).start();

Handlers in Android

Handlers are a fundamental component when dealing with threads in Android, especially for communication between threads. They allow you to send and process Message and Runnable objects associated with a thread's MessageQueue.

Key Concepts:

• MessageQueue: A queue that holds messages and runnable tasks to be executed by a handler.
• Message: An object that can hold various data and can be posted to a handler.
• Looper: A class that is associated with a thread and has a message queue. It loops and dispatches messages from the queue to the associated handler.

Creating and Using a Handler: You usually create a Handler in a worker thread to post messages and runnables back to the main thread.

// Inside your thread
public Handler createHandler(Looper looper) {
    return new Handler(looper) {
        @Override
        public void handleMessage(Message msg) {
            // Handle message
        }
    };
}

// Posting a Runnable
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
    @Override
    public void run() {
        // Update UI here
    }
});

Runnable in Android

Runnable is an interface that represents a unit of work to be executed by a thread. It is often used in conjunction with Handler to perform actions on the main thread from a background thread.

Key Concepts:

• Interface: It has a single method, run(), which contains the code to execute.
• Usage: It can be used to post tasks to another thread's message queue via a handler.

Using Runnable: