Was ist der Zweck von Looper und wie wird er verwendet?

Question

Ich bin neu bei Android. Ich möchte wissen, was die Looper Klasse und wie man sie benutzt. Ich habe die Android Dokumentation der Looper-Klasse aber ich bin nicht in der Lage, sie vollständig zu verstehen. Ich habe es an vielen Stellen gesehen, aber ich kann seinen Zweck nicht verstehen. Kann mir jemand helfen, indem er den Zweck von Looper und wenn möglich auch mit einem einfachen Beispiel?

Answer 1

Was ist Looper?

Looper ist eine Klasse, die zur Ausführung von Nachrichten (Runnables) in einer Warteschlange verwendet wird. Normale Threads haben keine solche Warteschlange, z.B. hat ein einfacher Thread keine Warteschlange. Er wird einmal ausgeführt und nachdem die Ausführung der Methode beendet ist, wird der Thread keine weitere Nachricht (Runnable) ausführen.

Wo können wir die Looper-Klasse verwenden?

Wenn jemand mehrere Nachrichten (Runnables) ausführen möchte, sollte er die Looper-Klasse verwenden, die für die Erstellung einer Warteschlange im Thread verantwortlich ist. Wenn wir zum Beispiel eine Anwendung schreiben, die Dateien aus dem Internet herunterlädt, können wir die Looper-Klasse verwenden, um die herunterzuladenden Dateien in die Warteschlange zu stellen.

Wie funktioniert das?

Es gibt prepare() Methode, um den Looper vorzubereiten. Dann können Sie die loop() Methode, um eine Nachrichtenschleife im aktuellen Thread zu erstellen. Nun ist Ihr Looper bereit, die Anfragen in der Warteschlange auszuführen, bis Sie die Schleife beenden.

Hier ist der Code, mit dem Sie den Looper vorbereiten können.

class LooperThread extends Thread {
      public Handler mHandler;

      @Override
      public void run() {
          Looper.prepare();

          mHandler = new Handler() {
              @Override
              public void handleMessage(Message msg) {
                  // process incoming messages here
              }
          };

          Looper.loop();
      }
  }

Answer 2

Sie können besser verstehen, was Looper im Zusammenhang mit dem GUI-Framework ist. Looper ist dafür gemacht, 2 Dinge zu tun.

1. Looper verwandelt einen normalen Thread in etwas, das kontinuierlich läuft, bis die Android-App läuft.

2. Looper stellt eine Warteschlange zur Verfügung, in die zu erledigende Aufgaben eingereiht werden.

Wie Sie vielleicht wissen, erstellt das System beim Starten einer Anwendung einen Ausführungsstrang (Thread) für die Anwendung, der als "main" bezeichnet wird, und Android-Anwendungen laufen normalerweise vollständig auf einem einzigen Thread, dem "main thread". Aber der Hauptthread ist kein geheimer, spezieller Thread . Es handelt sich um einen normalen Thread, ähnlich dem, den Sie mit new Thread() was bedeutet, dass es beendet wird, wenn seine run() Methode zurück! Denken Sie an das folgende Beispiel.

public class HelloRunnable implements Runnable {
    public void run() {
        System.out.println("Hello from a thread!");
    }

    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }
}

Nun wollen wir dieses einfache Prinzip auf Android-Apps anwenden. Was würde passieren, wenn eine Android-Anwendung auf einem normalen Thread läuft? Ein Thread namens "main" oder "UI" oder wie auch immer startet Ihre Anwendung und zeichnet die gesamte Benutzeroberfläche. Der erste Bildschirm wird also dem Benutzer angezeigt. Was passiert nun? Beendet sich der Haupt-Thread? Nein, das sollte er nicht. Er sollte warten, bis die Benutzer etwas tun, richtig? Aber wie können wir dieses Verhalten erreichen? Nun, wir können es versuchen mit Object.wait() o Thread.sleep() . Zum Beispiel beendet der Hauptthread seinen ersten Auftrag zur Anzeige des ersten Bildschirms und schläft. Er erwacht, d.h. er wird unterbrochen, wenn ein neuer Auftrag abgerufen wird. So weit, so gut, aber in diesem Moment brauchen wir eine Warteschlangen-ähnliche Datenstruktur, um mehrere Aufträge zu speichern. Stellen Sie sich einen Fall vor, in dem ein Benutzer den Bildschirm nacheinander berührt und eine Aufgabe längere Zeit braucht, um fertig zu werden. Wir brauchen also eine Datenstruktur, um Aufträge zu speichern, die nach dem Prinzip "first-in-first-out" erledigt werden. Wie Sie sich vielleicht vorstellen können, ist die Implementierung eines Threads, der immer läuft, wenn eine Aufgabe ankommt, nicht einfach und führt zu komplexem und oft nicht wartbarem Code. Wir würden lieber einen neuen Mechanismus für diesen Zweck schaffen, und darum geht es bei Looper . Die offizielles Dokument der Looper-Klasse sagt: "Threads haben standardmäßig keine Nachrichtenschleife, die mit ihnen verbunden ist", und Looper ist eine Klasse, "die verwendet wird, um eine Nachrichtenschleife für einen Thread auszuführen". Jetzt können Sie verstehen, was das bedeutet.

Um das zu verdeutlichen, sehen wir uns den Code an, in dem der Hauptthread umgewandelt wird. Das alles geschieht in ActivityThread-Klasse . In der main()-Methode finden Sie den folgenden Code, der einen normalen Thread in etwas verwandelt, das wir brauchen.

public final class ActivityThread {
    ...
    public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();
        Looper.loop();
        ...
    }
}

y [Looper.loop()](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/core/java/android/os/Looper.java) Methode in einer Endlosschleife eine Nachricht aus der Warteschlange nehmen und eine nach der anderen verarbeiten:

public static void loop() {
    ...
    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        ...
        msg.target.dispatchMessage(msg);
        ...
    }
}

Im Grunde ist Looper also eine Klasse, die ein Problem lösen soll, das im GUI-Framework auftritt. Aber diese Art von Bedarf kann auch in anderen Situationen auftreten. Eigentlich ist es ein ziemlich bekanntes Muster für Multi-Thread-Anwendungen, und Sie können mehr darüber erfahren in " Gleichzeitige Programmierung in Java " von Doug Lea (insbesondere das Kapitel 4.1.4 "Worker Threads" wäre hilfreich). Sie können sich auch vorstellen, dass diese Art von Mechanismus nicht nur im Android-Framework vorkommt, sondern dass alle GUI-Frameworks etwas Ähnliches benötigen. Sie können fast den gleichen Mechanismus auch im Java Swing Framework finden.

Answer 3

Looper ermöglicht die sequentielle Ausführung von Aufgaben auf einem einzigen Thread. Und der Handler definiert die Aufgaben, die ausgeführt werden müssen. Es ist ein typisches Szenario, das ich in diesem Beispiel zu veranschaulichen versuche:

class SampleLooper extends Thread {
@Override
public void run() {
  try {
    // preparing a looper on current thread     
    // the current thread is being detected implicitly
    Looper.prepare();

    // now, the handler will automatically bind to the
    // Looper that is attached to the current thread
    // You don't need to specify the Looper explicitly
    handler = new Handler();

    // After the following line the thread will start
    // running the message loop and will not normally
    // exit the loop unless a problem happens or you
    // quit() the looper (see below)
    Looper.loop();
  } catch (Throwable t) {
    Log.e(TAG, "halted due to an error", t);
  } 
}
}

Jetzt können wir den Handler in einigen anderen Threads (z.B. UI-Thread) verwenden, um die Aufgabe an Looper zur Ausführung zu senden.

handler.post(new Runnable()
{
public void run() {
//This will be executed on thread using Looper.
    }
});

Auf dem UI-Thread haben wir einen impliziten Looper, der uns erlaubt, die Nachrichten auf dem UI-Thread zu behandeln.

Answer 4

Android Looper ist ein Wrapper zum Anhängen von MessageQueue a Thread und verwaltet die Warteschlangenverarbeitung. Es sieht in der Android-Dokumentation sehr kryptisch aus und oft können wir mit Looper Probleme beim Zugriff auf die Benutzeroberfläche. Wenn wir die Grundlagen nicht verstehen, wird es sehr schwierig, damit umzugehen.

Hier ist ein Artikel die erklärt Looper Lebenszyklus, seine Verwendung und die Verwendung von Looper において Handler

Looper = Thread + MessageQueue

Answer 5

Die einfachste Definition von Looper & Handler:

Looper ist eine Klasse, die einen Thread in eine Rohrleitungsgewinde y Handler bietet Ihnen einen Mechanismus, um Aufgaben aus anderen Threads in diese Pipe zu schieben.

Einzelheiten im allgemeinen Wortlaut:

Also ein PipeLine-Gewinde ist ein Thread, der über einen Handler weitere Aufgaben von anderen Threads annehmen kann.

El Looper heißt so, weil es die Schleife implementiert - es nimmt die nächste Aufgabe, führt sie aus, nimmt dann die nächste und so weiter. Der Handler wird so genannt, weil er die nächste Aufgabe jedes Mal von einem anderen Thread übernimmt und an den Looper (Thread oder PipeLine Thread) weitergibt.

例

Ein Looper- und Handler- oder PipeLine-Thread ist ein perfektes Beispiel, um mehrere Bilder herunterzuladen oder auf einen Server (Http) hochzuladen, und zwar eines nach dem anderen in einem einzigen Thread, anstatt für jeden Netzwerkaufruf im Hintergrund einen neuen Thread zu starten.

Lesen Sie hier mehr über Looper und Handler und die Definition von Pipeline Thread:

Android Guts: Einführung in Looper und Handler