Android: Wann sollte ich einen Handler() und wann einen Thread verwenden?

Wenn ich etwas zum Laufen brauche asynchron, so wie ein lang andauernde Aufgabe oder eine Logik, die das Netzwerk verwendet, oder aus welchem ​​Grund auch immer, Starten a neues Thema und das laufen funktioniert einwandfrei. Ein … Erstellen Handler und ausführen funktioniert auch. Was ist der Unterschied? Wann sollte ich welche verwenden? Was sind die Vorteile / Gründe für die Verwendung von a Handler und nicht ein Thread?

PS. – Um dieser Frage willen ignorieren wir sie AsyncTask. – Handler().postDelayed Anwendungsfall ist mir klar, um dieser Frage willen nehmen wir an, ich brauche die Aufgabe, um sofort zu beginnen.

Wenn das, was Sie tun, “schwer” ist, sollten Sie es in einem Thread tun. Wenn Sie es nicht explizit in einem eigenen Thread starten, wird es im Hauptthread (UI) ausgeführt, was von Ihren Benutzern als nervös oder langsam reagierende Benutzeroberfläche wahrgenommen werden kann.

Interessanterweise ist es bei der Verwendung eines Threads oft nützlich, auch einen Handler als Kommunikationsmittel zwischen dem Arbeits-Thread, den Sie starten, und dem Haupt-Thread zu verwenden.

Eine typische Thread/Handler-Interaktion könnte etwa so aussehen:

Handler h = new Handler(){
    @Override
    public void handleMessage(Message msg){
        if(msg.what == 0){
            updateUI();
        }else{
            showErrorDialog();
        }
    }
};

Thread t = new Thread() {
    @Override
    public void run(){
        doSomeWork();
        if(succeed){
            //we can't update the UI from here so we'll signal our handler and it will do it for us.
            h.sendEmptyMessage(0);
        }else{
            h.sendEmptyMessage(1);
        }
    }   
};

Im Allgemeinen gilt jedoch, dass Sie einen Thread immer dann verwenden sollten, wenn Sie Arbeiten erledigen, die langwierig oder sehr intensiv sein könnten (z. B. alles Netzwerk, Datei-E / A, schwere Arithmetik usw.).

Handler und Thread sind wirklich 2 verschiedene Dinge.

Ein Thread muss erstellt werden, um lang andauernde Jobs auszuführen.

Ein Handler ist ein sehr praktisches Objekt, um zwischen 2 Threads zu kommunizieren (zum Beispiel: ein Hintergrund-Thread muss die Benutzeroberfläche aktualisieren. Sie können einen Handler verwenden, um einige Runnables von Ihrem Hintergrund-Thread an den UI-Thread zu senden).

Sie haben also nicht die Wahl zwischen Handler oder Thread. Verwenden Sie einen Faden, um schwere Aufgaben zu erledigen! (Sie können einen Handler verwenden, wenn Ihr Hintergrundthread eine Aufgabe auslöst, die in einem anderen Thread erledigt werden soll – meistens der UI-Thread)

Handler und Thread sind zwei verschiedene Dinge, aber sie widersprechen sich nicht. Sie können eine haben Handler und ein Thread gleichzeitig und eigentlich jeder Handler muss in a laufen Thread.

Für weitere Details möchten Sie vielleicht Schauen Sie sich diesen Artikel an.

EIN Handler läuft auf dem gleichen Thread, ein Thread läuft in einem anderen Thread.

Verwenden Sie einen Handler, wenn Sie etwas im selben Thread ausführen müssen, normalerweise ein GUI-Element oder so ähnlich.

Verwenden Sie einen Thread, wenn Sie den Haupt-Thread frei halten möchten, um andere Dinge zu tun. Verwenden Sie dies für alles, was viel Zeit in Anspruch nimmt.

Handler sind die beste Art der Kommunikation zwischen dem Hintergrund und dem UI-Thread. Im Allgemeinen sind Handler mit der Nachrichtenwarteschlange eines Threads verknüpft und werden verwendet, um Nachrichten zu senden und für die Nachricht auszuführen.

BENUTZEN:

Faden: Um Aufgaben in einem separaten (Hintergrund-)Thread als UI-Thread auszuführen. (hilft beim Entsperren des UI-Threads)

Handler Wird verwendet, um zwischen der Benutzeroberfläche und dem Hintergrund-Thread zu kommunizieren.

Guck dir das an Artikel

Wenn Sie die Benutzeroberfläche von einem neuen Thread aktualisieren müssen, müssen Sie mit dem Benutzeroberflächen-Thread synchronisieren.

Sie können dafür die Klasse android.os.Handler oder die Klasse AsyncTasks verwenden.

Die Handler-Klasse kann die Benutzeroberfläche aktualisieren. Ein Handler stellt Methoden zum Empfangen von Instanzen der Klasse Message oder Runnable bereit.

Ihr Thread kann Nachrichten über die Methode sendMessage(Message msg) oder über die Methode sendEmptyMessage() posten.

… Mehr Info Hier über Threads usw. (enthält Tutorials für die verschiedenen Threading- und Synchronisierungsmechanismen und wann man was verwendet)

Was sind die Vorteile / Gründe, einen Handler und keinen Thread zu verwenden?

EIN Handler ermöglicht Ihnen das Senden und Verarbeiten von Nachrichten und Runnable Objekte, die einem Thread zugeordnet sind MessageQueue. Jeder Handler -Instanz ist einem einzelnen Thread und der Nachrichtenwarteschlange dieses Threads zugeordnet.

Wenn Sie eine neue erstellen Handler, ist es an den Thread / die Nachrichtenwarteschlange des Threads gebunden, der es erstellt — von diesem Zeitpunkt an liefert es Nachrichten und Runnables an diese Nachrichtenwarteschlange und führt sie aus, wenn sie aus der Nachrichtenwarteschlange kommen.

Es gibt zwei Hauptverwendungen für einen Handler:

1. Um Nachrichten zu planen und Runnables irgendwann in der Zukunft ausgeführt werden
2. Zu einreihen eine Aktion, die in einem anderen Thread als Ihrem eigenen ausgeführt werden soll.

Wenn Sie Java-Threads verwenden, müssen Sie einiges selbst erledigen – mit dem Hauptthread synchronisieren, einen Thread abbrechen usw.

Dieser einzelne Thread erstellt keinen Thread-Pool, es sei denn, Sie verwenden ThreadPoolExecutor oder ExecutorService API.

(Diese Frage stammt aus Ihren Kommentaren zur Blackbelt-Antwort)

Warum nicht einen Vollstrecker verwenden? und selbst wenn ich dafür einen Handler verwenden wollte, wie?

Bezug : Artikel zur Threadleistung

Es gibt bestimmte Arten von Arbeit, die auf hochgradig parallele, verteilte Aufgaben reduziert werden können. Bei der schieren Menge an Arbeitspaketen, die dadurch entstehen, AsyncTask und HandlerThread sind keine geeigneten Klassen. Die Singlethread-Natur von AsyncTask würde die gesamte Threadpool-Arbeit in ein lineares System verwandeln. Verwendung der HandlerThread Klasse hingegen würde erfordern, dass der Programmierer den Lastausgleich zwischen einer Gruppe von Threads manuell verwaltet.

ThreadPoolExecutor ist eine Hilfsklasse, die diesen Vorgang vereinfacht. Diese Klasse verwaltet die Erstellung einer Gruppe von Threads, legt ihre Prioritäten fest und verwaltet, wie die Arbeit auf diese Threads verteilt wird. Wenn die Arbeitslast zunimmt oder abnimmt, dreht die Klasse mehr Threads hoch oder zerstört sie, um sich an die Arbeitslast anzupassen.

 BlockingQueue workQueue= new LinkedBlockingQueue<Runnable>(100); // Work pool size
 ThreadPoolExecutor executor = new ThreadPoolExecutor(
            Runtime.getRuntime().availableProcessors(),       // Initial pool size
            Runtime.getRuntime().availableProcessors(),       // Max pool size
            1, // KEEP_ALIVE_TIME
            TimeUnit.SECONDS, //  KEEP_ALIVE_TIME_UNIT
            workQueue);

Sie können auf diesen Artikel im Entwicklerhandbuch verweisen threadpool erstellen für mehr Details.

Schauen Sie sich diesen Beitrag zur Verwendung von an Handler um mehrere ausführbare Instanzen auszuführen. In diesem Fall alle Runnable Aufgaben werden in einem einzigen Thread ausgeführt.

Android: Toast in einem Thread