Was ist ein Handler in Android?

Ein Handler in Android ist ein Mechanismus für die Interaktion zwischen Threads. Er ermöglicht das Senden und Verarbeiten von Message und Runnable von einem Thread in die Nachrichtenwarteschlange (MessageQueue) eines anderen Threads (meistens des UI-Threads).

Hauptkomponenten:

• Handler: Objekt, das mit einem bestimmten Thread und dessen MessageQueue verbunden ist. Sendet Nachrichten und Runnables in die Warteschlange und verarbeitet sie, indem es sie daraus extrahiert.
• Looper: Objekt, das an einen Thread gebunden ist. Es "startet" den Thread, indem es kontinuierlich Aufgaben (Message oder Runnable) aus der MessageQueue extrahiert und sie an den entsprechenden Handler zur Verarbeitung weitergibt.
• MessageQueue: Aufgabenwarteschlange (Message oder Runnable), die vom Looper verarbeitet werden sollen.

Funktionsweise:

1. Der Handler wird im Thread erstellt, der die Nachrichten verarbeiten soll (z.B. UI-Thread).
2. Dieser Handler ist mit dem Looper dieses Threads und seiner MessageQueue verbunden.
3. Aus einem anderen Thread (z.B. im Hintergrund) können Nachrichten oder Runnables an die MessageQueue gesendet werden, z.B. mittels der Methoden des Handlers (post oder sendMessage).
4. Der Looper des empfangenden Threads extrahiert Aufgaben aus der MessageQueue.
5. Der Looper übergibt jede Aufgabe an den entsprechenden Handler zur Verarbeitung.

Beispiel zur Aktualisierung der UI aus einem Hintergrund-Thread:

// Handler im UI-Thread erstellen
Handler uiHandler = new Handler(Looper.getMainLooper());

// Im Hintergrund-Thread:
new Thread(new Runnable() {
    @Override
    public void run() {
        // Lange Operation ausführen...

        // UI mit Handler aktualisieren
        uiHandler.post(new Runnable() {
            @Override
            public void run() {
                // Hier Code, der die UI sicher aktualisiert
                textView.setText("Operation abgeschlossen!");
            }
        });
    }
}).start();

Handler wird verwendet, um Operationen sicher in einem bestimmten Thread (meistens UI) auszuführen, ohne den Haupt-Thread zu blockieren. Dies ist notwendig, da die meisten UI-Operationen nur im Haupt-Thread ausgeführt werden dürfen.