Handler vs. AsyncTask vs. Thread

Question

Ich war etwas verwirrt über die Unterschiede zwischen Handlers , AsyncTask y Threads in Android. Ich habe eine ganze Reihe von Blogs und Fragen hier in StackOverflow gelesen.

Handler sind Hintergrund-Threads, die Ihnen die Kommunikation mit der Benutzeroberfläche ermöglichen. Die Aktualisierung eines Fortschrittsbalkens zum Beispiel sollte über Handler . Die Verwendung von Handlern hat den Vorteil, dass sie MessagingQueues Wenn Sie also Nachrichten planen, mehrere Elemente der Benutzeroberfläche aktualisieren oder sich wiederholende Aufgaben durchführen möchten, können Sie dies tun.

AsyncTask ähneln sich in der Tat, denn sie nutzen die Handler , läuft aber nicht im UI-Thread und eignet sich daher gut zum Abrufen von Daten, z. B. zum Abrufen von Webdiensten. Später können Sie mit der Benutzeroberfläche interagieren.

Thread kann jedoch nicht mit der Benutzeroberfläche interagieren, bietet "einfacheres" Threading und man vermisst alle Abstraktionen von AsyncTask .

Ich möchte jedoch eine Socket-Verbindung im Dienst laufen lassen. Sollte dies in einem Handler oder einem Thread oder sogar einem AsyncTask ? UI-Interaktion ist überhaupt nicht notwendig. Macht es einen Unterschied in Bezug auf die Leistung, welche ich verwende?

Inzwischen ist die Dokumentation wurde erheblich verbessert.

Answer 1

AsyncTask ist darauf ausgelegt, Operationen im Hintergrund auszuführen, die nicht länger als ein paar Sekunden dauern (nicht empfohlen für das Herunterladen von Dateien im Megabyte-Bereich vom Server oder rechenintensive Aufgaben wie Datei-IO-Operationen). Wenn Sie eine lang andauernde Operation ausführen müssen, wird Ihnen dringend empfohlen, Java native Threads zu verwenden. Java stellt Ihnen verschiedene Thread-bezogene Klassen zur Verfügung, um das zu tun, was Sie brauchen. Verwenden Sie Handler um den UI-Thread zu aktualisieren.

Answer 2

public class RequestHandler {

    public String sendPostRequest(String requestURL,
                                  HashMap<String, String> postDataParams) {

        URL url;

        StringBuilder sb = new StringBuilder();
        try {
            url = new URL(requestURL);

            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setReadTimeout(15000);
            conn.setConnectTimeout(15000);
            conn.setRequestMethod("POST");
            conn.setDoInput(true);
            conn.setDoOutput(true);

            OutputStream os = conn.getOutputStream();
            BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(os, "UTF-8"));
            writer.write(getPostDataString(postDataParams));

            writer.flush();
            writer.close();
            os.close();
            int responseCode = conn.getResponseCode();

            if (responseCode == HttpsURLConnection.HTTP_OK) {
                BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
                sb = new StringBuilder();
                String response;
                while ((response = br.readLine()) != null){
                    sb.append(response);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        return sb.toString();
    }

    private String getPostDataString(HashMap<String, String> params) throws UnsupportedEncodingException {
        StringBuilder result = new StringBuilder();
        boolean first = true;
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (first)
                first = false;
            else
                result.append("&");

            result.append(URLEncoder.encode(entry.getKey(), "UTF-8"));
            result.append("=");
            result.append(URLEncoder.encode(entry.getValue(), "UTF-8"));
        }

        return result.toString();
    }

}

Answer 3

Die Wahl hängt von der jeweiligen Anforderung ab

Handler wird meist verwendet, um von einem anderen Thread zum Hauptthread zu wechseln. Der Handler ist mit einem Looper verbunden, auf dem er seine lauffähige Aufgabe in die Warteschlange stellt. Wenn Sie also bereits in einem anderen Thread sind und zum Hauptthread wechseln, benötigen Sie Handle anstelle einer asynchronen Aufgabe oder eines anderen Threads.

Wenn der Handler in einem anderen Thread als dem Hauptthread erstellt wird, der kein Looper ist, wird es keinen Fehler geben, da der Handle im Thread erstellt wird, dieser Thread muss zu einem Lopper gemacht werden

AsyncTask wird verwendet, um Code für einige Sekunden auszuführen, der im Hintergrund-Thread läuft und sein Ergebnis an den Haupt-Thread weitergibt ** *AsyncTask-Einschränkungen 1. Async Task ist nicht an den Lebenszyklus der Aktivität gebunden und läuft weiter, auch wenn die Aktivität zerstört wird, während Loader diese Einschränkung nicht hat. 2. Alle Async Tasks teilen sich denselben Hintergrund-Thread für die Ausführung, was sich auch auf die Leistung der App auswirkt

Thema wird in der App auch für die Hintergrundarbeit verwendet, hat aber keinen Rückruf auf den Hauptthread. Wenn Anforderung passt einige Threads anstelle von einem Thread und die Aufgabe viele Male dann Thread-Pool Executor geben müssen, ist bessere option.Eg Anforderung von Bild-Laden von mehreren url wie Glide.

Answer 4

Thema

Wenn Sie eine Anwendung starten, wird ein Prozess zur Ausführung des Codes erstellt. Um Rechenressourcen effizient zu nutzen, können innerhalb des Prozesses Threads gestartet werden, so dass mehrere Aufgaben gleichzeitig ausgeführt werden können. Mit Threads können Sie also effiziente Anwendungen erstellen, indem Sie die CPU effizient und ohne Leerlaufzeiten nutzen.

In Android werden alle Komponenten auf einem einzigen sogenannten Haupt-Thread ausgeführt. Das Android-System stellt Aufgaben in eine Warteschlange und führt sie nacheinander auf dem Hauptthread aus. Wenn lang laufende Aufgaben ausgeführt werden, reagiert die App nicht mehr.

Um dies zu verhindern, können Sie Worker-Threads erstellen und Hintergrund- oder lang laufende Aufgaben ausführen.

Handler

Da Android ein Single-Thread-Modell verwendet, werden UI-Komponenten nicht-thread-sicher erstellt, d.h. nur der Thread, der sie erstellt hat, sollte auf sie zugreifen, was bedeutet, dass die UI-Komponente nur im Hauptthread aktualisiert werden sollte. Da die UI-Komponente auf dem Haupt-Thread läuft, können Aufgaben, die auf Worker-Threads laufen, die UI-Komponenten nicht ändern. An dieser Stelle kommt der Handler ins Spiel. Handler können mit Hilfe von Looper eine Verbindung zu einem neuen oder bestehenden Thread herstellen und den darin enthaltenen Code auf dem verbundenen Thread ausführen.

Handler ermöglicht die Kommunikation zwischen Threads. Mit Handler kann der Hintergrund-Thread Ergebnisse an ihn senden und der Handler, der mit dem Haupt-Thread verbunden ist, kann die UI-Komponenten auf dem Haupt-Thread aktualisieren.

AsyncTask

AsyncTask, das von Android bereitgestellt wird, verwendet sowohl Thread als auch Handler, um die Ausführung einfacher Aufgaben im Hintergrund und die Aktualisierung der Ergebnisse vom Hintergrundthread zum Hauptthread zu vereinfachen.

Siehe bitte Android Thread, Handler, Asynctask und Thread-Pools für Beispiele.

Answer 5

Handler - ist das Kommunikationsmedium zwischen den Threads. In Android wird es hauptsächlich für die Kommunikation mit dem Hauptthread verwendet, indem Nachrichten über Handler erstellt und gesendet werden

AsyncTask - wird verwendet, um lang laufende Anwendungen in einem Hintergrund-Thread auszuführen. Mit n AsyncTask können Sie die Operation in einem Hintergrund-Thread durchführen und das Ergebnis im Haupt-Thread der Anwendung abrufen.

Thread - ist ein leichtgewichtiger Prozess, um Gleichzeitigkeit und maximale CPU-Nutzung zu erreichen. In Android können Sie Threads verwenden, um Aktivitäten durchzuführen, die die Benutzeroberfläche der App nicht berühren