Was ist Looper in Android?

Looper ist eine Klasse in Android, die verwendet wird, um den Fluss (Thread) zu verwalten und ihn "Looping" (zyklisch) zu machen. Es bereitet den Thread vor, um Nachrichten aus der MessageQueue zu verarbeiten, bis er explizit beendet wird.

Hauptkomponenten von Looper:

• MessageQueue: Warteschlange, die Nachrichten (Message) und Aufgaben (Runnable) speichert, die im Thread des Loopers ausgeführt werden sollen. Es ist eine threadsichere Struktur.
• Looper: Verbindet den Thread mit der MessageQueue und extrahiert zyklisch Nachrichten aus der Warteschlange für die weitere Verarbeitung.
• Handler: Objekt, das Nachrichten und Aufgaben in die MessageQueue des Loopers stellt und sie bei der Extraktion verarbeitet. Handler ist an einen bestimmten Looper gebunden.

Funktionsweise von Looper:

1. Vorbereitung: Im Thread wird Looper.prepare() aufgerufen. Dies erstellt eine neue Instanz von Looper und bindet sie an den aktuellen Thread. Es wird auch eine MessageQueue für diesen Looper erstellt.
2. Start des Zyklus: Looper.loop() wird aufgerufen. Diese Methode tritt in eine unendliche Schleife ein (bis der Looper beendet wird). In der Schleife überprüft der Looper ständig die MessageQueue auf neue Nachrichten.
3. Nachrichtenverarbeitung: Wenn eine Nachricht gefunden wird, extrahiert Looper sie und sendet sie an einen Handler, der sie zur Warteschlange hinzugefügt hat. Der Handler führt die entsprechende Aufgabe aus (z.B. handleMessage() oder run() für Runnable).
4. Beendigung: Um die Schleife zu verlassen und den Looper zu beenden, muss Looper.quit() oder Looper.quitSafely() aufgerufen werden.

Typischer Einsatz von Looper:

• Erstellen von Hintergrund-Threads, die Aufgaben asynchron ausführen und Nachrichten vom UI-Thread oder anderen Threads empfangen sollen.
• Verwendung in Services (IntentService verwendet einen eingebauten Looper).
• Arbeit mit HandlerThread (eine spezielle Thread-Klasse, die ihren eigenen Looper und MessageQueue erstellt).

Beispiel für die Erstellung eines Threads mit Looper und Handler:

// Thread erstellen und starten
HandlerThread handlerThread = new HandlerThread("MyWorkerThread");
handlerThread.start();

// Looper vom Thread erhalten
Looper looper = handlerThread.getLooper();

// Handler erstellen, der an den Looper gebunden ist
Handler handler = new Handler(looper) {
    @Override
    public void handleMessage(Message msg) {
        // Nachrichten im Worker-Thread verarbeiten
        // msg.what enthält die Nachrichten-ID
        // msg.obj oder msg.data können Daten enthalten
        switch (msg.what) {
            case 1:
                // Nachricht vom Typ 1 verarbeiten
                break;
            case 2:
                // Nachricht vom Typ 2 verarbeiten
                break;
        }
    }
};

// Nachricht an den Worker-Thread senden
handler.sendEmptyMessage(1);

// Oder Runnable ausführen
handler.post(new Runnable() {
    @Override
    public void run() {
        // Code, der im Worker-Thread ausgeführt wird
    }
});

// Wenn der Thread nicht mehr benötigt wird, Looper und Thread beenden
handlerThread.quitSafely();