Handler vs AsyncTask vs Thread

si vous regardez le code source de AsyncTask et Handler , vous verrez que leur code est écrit purement en Java. (Bien sûr, il y a quelques exceptions, mais ce n'est pas un point important.)

il n'y a donc pas de magie dans AsyncTask ou Handler . Ils rendent juste votre travail plus facile en tant que développeur.

par exemple: si le Programme A appelle la méthode A (), la méthode A () pourrait exécuter un thread différent avec le programme A. Vous pouvez facilement le vérifier

Thread t = Thread.currentThread();    
int id = t.getId();

Pourquoi utiliser un nouveau fil? Vous pouvez chercher sur google. De nombreuses de nombreuses raisons.

Alors, quelle est la différence entre Thread , AsyncTask , et Handler ?

AsyncTask et Handler sont écrits en Java (à l'interne qu'ils utilisent un Thread ), donc tout ce que vous pouvez faire avec Handler ou AsyncTask , vous pouvez réaliser à l'aide d'un Thread .

quoi peut Handler et AsyncTask vraiment vous aider?

la raison la plus évidente est la communication entre le fil appelant et le fil travailleur. ( Caller Thread : un thread qui appelle le Worker Thread pour effectuer une tâche. Un fil appelant ne doit pas nécessairement être le fil UI). Bien sûr, vous pouvez communiquer entre deux fils d'autres façons, mais il ya beaucoup d'inconvénients (et les dangers) en raison de problèmes de sécurité du fil.

C'est pourquoi vous devez utiliser Handler et AsyncTask . Ils font la plupart du travail pour vous, vous avez juste besoin de savoir quelles méthodes pour outrepasser.

la différence entre Handler et AsyncTask est la suivante: utilisez AsyncTask lorsque fil appelant est un fil UI . C'est ce que dit le document android:

AsyncTask active les et l'utilisation facile du fil UI. Cette classe permet d'effectuer des opérations de fond et de publier des résultats sur L'interface utilisateur fil sans avoir à manipuler les threads et/ou les gestionnaires d'

je veux insister sur deux points:

1) Utilisation facile du fil UI (donc, utiliser quand le fil appelant est le fil UI).

2) pas besoin de manipuler les manipulateurs. (signifie: Vous pouvez utiliser Handler au lieu D'AsyncTask, mais AsyncTask est plus facile option.)

il y a beaucoup de choses dans ce post que je n'ai pas encore dit, par exemple: qu'est-ce que le fil UI, ou pourquoi il est plus facile. Vous devez connaître une méthode derrière chaque sorte et l'utiliser, vous comprendrez complètement pourquoi..

@: quand vous lisez le document Android, vous verrez:

Handler vous permet d'envoyer et de traiter des messages et des objets exécutables associé à la MessageQueue d'un fil

ils peuvent sembler étranges au début. Il suffit de comprendre que chaque fil a chaque file d'attente de message (comme une liste à faire), et le fil va prendre chaque message et le faire jusqu'à ce que la file d'attente de message est vide (tout comme vous finissez votre travail et aller au lit). Ainsi, quand Handler communique, il donne juste un message au fil de l'appelant et il attendra de traiter. Compliqué? Il suffit de se rappeler que Handler peut communiquer avec le fil appelant d'une manière sûre.

après avoir regardé en profondeur, c'est tout droit.

AsyncTask :

C'est une façon simple d'utiliser un thread sans rien connaître du modèle java thread . AsyncTask donne divers callbacks respectivement au thread de travail et au thread principal.

utilisation pour les petites opérations d'attente comme:

1. aller chercher quelques données de services web et d'affichage sur la mise en page.
2. requête de base de données.
3. quand vous réalisez que le fonctionnement ne sera jamais, jamais imbriqué.

Handler :

quand nous installons une application dans android, puis il crée un thread pour cette application appelé UI Thread principal. Toutes les activités se déroulent dans ce fil. Par la règle de modèle de fil simple android, nous pouvons ne pas accéder aux éléments de L'interface utilisateur (bitmap, textview, etc..) directement pour un autre fil défini à l'intérieur de cette activité.

un Handler vous permet de communiquer avec le thread UI d'un autre thread d'arrière-plan. Ceci est utile pour android Car android ne permet pas aux autres threads de communiquer directement avec UI thread. Handler peut envoyer et traiter des messages et des objets exécutables associés à la MessageQueue d'un thread. Chaque instance du gestionnaire est associée à un seul thread et que la file d'attente de messages de thread. Lorsqu'un nouveau gestionnaire est créé, il est lié à la file d'attente thread/message du thread qui le crée.

C'est le meilleur ajustement pour:

1. il vous permet de faire la queue des messages.
2. Message de la planification.

Thread :

maintenant il est temps de parler de fil.

le fil est le parent des deux AsyncTask et Handler . Ils utilisent tous les deux en interne thread, qui signifie vous pouvez également créer votre propre modèle de thread comme AsyncTask et Handler , mais cela nécessite une bonne connaissance de Java multi-Threading Implementation .

An AsyncTask est utilisé pour faire un calcul de fond et publier le résultat dans le thread de L'interface utilisateur (avec des mises à jour de progression optionnelles). Puisque vous n'êtes pas concerné par L'assurance-chômage, alors un Handler ou Thread semble plus approprié.

vous pouvez générer un background Thread et transmettre des messages à votre thread principal en utilisant la méthode Handler 's post .

Thread

Android prend en charge Java standard Threads . Vous pouvez utiliser les Threads standard et les outils du paquet " java.util.concurrent " pour mettre des actions en arrière-plan. La seule limitation est que vous ne pouvez pas mettre à jour directement L'interface utilisateur à partir du processus a background.

si vous devez mettre à jour L'interface utilisateur à partir d'une tâche de fond, vous devez utiliser certaines classes spécifiques à Android. Vous pouvez utiliser l' classe " android.os.Handler "pour cette classe ou pour la classe" AsyncTask "

Gestionnaire

la classe " Handler " peut mettre à jour L'UI. Une poignée fournit des méthodes pour la réception des messages et pour les exécutables. Pour utiliser un gestionnaire, vous devez le sous-classe et remplacer handleMessage() pour traiter les messages. Runable , vous pouvez utiliser la méthode post(); Vous avez seulement besoin d'une instance d'un gestionnaire dans votre activité.

vous thread pouvez poster des messages via la méthode sendMessage(Message msg) ou sendEmptyMessage .

AsyncTask

si vous avez un Activity qui a besoin de télécharger le contenu ou d'effectuer des opérations qui peuvent être faites en arrière-plan AsyncTask vous permet de maintenir une interface utilisateur responsive et de publier le progrès pour ces opérations à l'utilisateur.

Pour plus d'informations, vous pouvez jeter un oeil à ces liens.

http://mobisys.in/blog/2012/01/android-threads-handlers-and-asynctask-tutorial/

http://www.slideshare.net/HoangNgoBuu/android-thread-handler-and-asynctask

à mon avis, les threads ne sont pas le moyen le plus efficace de faire des connexions socket, mais ils offrent la plus grande fonctionnalité en termes de fonctionnement des threads. Je dis cela parce que d'après mon expérience, l'exécution de threads pendant une longue période Fait en sorte que les appareils sont très chauds et exigent beaucoup de ressources. Même un simple while(true) chauffe un téléphone en quelques minutes. Si vous dites que L'interaction avec L'UI n'est pas importante, peut-être qu'un AsyncTask est bon parce qu'ils sont conçus pour des processus à long terme. Ce n'est que mon avis sur elle.

mise à JOUR

Veuillez ne pas tenir compte de ma réponse ci-dessus! j'ai répondu à cette question en 2011 quand j'étais beaucoup moins expérimenté dans Android que je le suis maintenant. Ma réponse ci-dessus est trompeuse et est considéré comme mauvais. Je le laisse là parce que beaucoup de gens l'ont commenté plus bas en me corrigeant, et j'ai appris ma leçon.

Il ya beaucoup mieux d'autres réponses sur ce fil, mais je vais au moins me donner la bonne réponse. Il n'y a rien de mal à utiliser un Java Thread régulier ; cependant, vous devez vraiment faire attention à la façon dont vous l'implémentez car faire une erreur peut être très intensif processeur (symptôme le plus notable peut être votre appareil échauffement). AsyncTask s sont assez idéal pour la plupart des tâches que vous voulez exécuter en arrière-plan (exemples communs sont l'E/S disque, les appels réseau, et les appels de base de données). Cependant, AsyncTask s ne doit pas être utilisé pour les longs processus qui peuvent avoir besoin de continuer après que l'Utilisateur a fermé votre application ou mis son appareil en veille. Je dirais que dans la plupart des cas, tout ce qui n'appartient pas au fil UI peut être pris en charge dans un AsyncTask .

Thread :

vous pouvez utiliser le nouveau Thread pour les tâches de fond de longue durée sans impact sur le thread de L'interface utilisateur. Depuis java Thread, vous ne pouvez pas mettre à jour UI Thread.

depuis normal Thread n'est pas très utile pour l'architecture Android, classes helper pour threading ont été introduits.

vous pouvez trouver des réponses à vos questions dans Threading performance page de documentation.

Gestionnaire :

a Handler vous permet d'envoyer et de traiter des messages et des objets Runnable associés à un thread MessageQueue . Chaque instance Handler est associée à un seul thread et à la file d'attente de messages de ce thread.

il existe deux utilisations principales pour un Handler :

1. pour programmer des messages et runnables pour être exécuté comme un certain moment dans l'avenir;

2. pour demander une action à exécuter sur un fil différent du vôtre.

AsyncTask :

AsyncTask permet une utilisation correcte et facile du fil UI. Cette classe vous permet d'effectuer des opérations de fond et de publier des résultats sur le thread sans avoir à manipuler les threads et/ou les gestionnaires.

Inconvénients:

1. par défaut, une application pousse tous les objets AsyncTask qu'elle crée dans un seul thread. Par conséquent, ils s'exécutent en série, et-comme avec le thread principal-un paquet de travail particulièrement long peut bloquer la file d'attente. Pour cette raison, utilisez AsyncTask pour manipuler des éléments de travail plus court que 5ms de durée .

2. AsyncTask les objets sont aussi les plus communs pour les questions implicites de référence. Les objets AsyncTask présentent également des risques liés aux références explicites.

HandlerThread :

vous pourriez avoir besoin d'une approche plus traditionnelle pour exécuter un bloc de travail sur un fil plus long ( contrairement à AsyncTask, qui devrait être utilisé pour la charge de travail de 5ms ), et une certaine capacité à gérer ce flux de travail manuellement. Un thread handler est effectivement un thread de longue durée qui saisit le travail à partir d'une file d'attente, et opère sur celle-ci.

ThreadPoolExecutor :

cette classe gère la création d'un groupe de fils, fixe leurs priorités, et gère la façon dont le travail est distribué parmi ces fils. Comme la charge de travail augmente ou diminue, la classe tourne en haut ou détruit plus de threads à ajuster la charge de travail.

si la charge de travail est plus et seul HandlerThread n'est pas suffisant, vous pouvez aller pour ThreadPoolExecutor

cependant, je voudrais qu'une connexion socket fonctionne dans un service. Cela doit-il être exécuté dans un handler ou un thread, ou même un AsyncTask? L'interaction avec L'assurance-chômage n'est pas nécessaire du tout. Fait-il une différence en termes de performances que j'utilise?

puisque L'interaction avec L'assurance-chômage est pas obligatoire, vous ne pouvez pas aller pour AsyncTask . Les threads normaux ne sont pas très utiles et donc HandlerThread est la meilleure option. Puisque vous devez maintenir la connexion socket, Handler sur le thread principal n'est pas utile du tout. Créer un HandlerThread et obtenir un Handler de looper de HandlerThread .

 HandlerThread handlerThread = new HandlerThread("SocketOperation");
 handlerThread.start();
 Handler requestHandler = new Handler(handlerThread.getLooper());
 requestHandler.post(myRunnable); // where myRunnable is your Runnable object. 

si vous voulez communiquer de nouveau avec le thread de L'UI, vous pouvez utiliser un gestionnaire de plus pour traiter la réponse.

final Handler responseHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            //txtView.setText((String) msg.obj);
            Toast.makeText(MainActivity.this,
                    "Foreground task is completed:"+(String)msg.obj,
                    Toast.LENGTH_LONG)
                    .show();
        }
    };

dans votre Runnable , vous pouvez ajouter

responseHandler.sendMessage(msg);

pour plus de détails sur la mise en œuvre, Cliquez ici:

Android: grillé dans un thread

AsyncTask est conçu pour effectuer pas plus de quelques secondes de fonctionnement en arrière-plan (non recommandé pour les mégaoctets de téléchargement de fichier à partir du serveur ou de calculer des tâches intensives de cpu telles que les opérations de fichier IO ). Si vous devez exécuter une opération de longue durée, il vous a été fortement conseillé d'utiliser les threads java native. Java vous donne différentes classes de thread pour faire ce que vous avez besoin. Utilisez Handler pour mettre à jour le Thread.

laissez - moi essayer de répondre à la question ici avec un exemple:) - MyImageSearch [se référer à L'image ici de l'écran d'activité principale-contenant un texte d'édition / bouton de recherche / vue de grille]

Description de MyImageSearch - une fois que l'utilisateur entre les détails sur le champ modifier le texte et clique sur le bouton de recherche, nous allons rechercher des images sur le internet via les services web fournis par flickr (vous n'avez besoin de vous y inscrire que pour obtenir une clé/jeton secret) - pour la recherche, nous envoyons une demande HTTP et récupérons des données JSON en réponse contenant les url des images individuelles que nous utiliserons ensuite pour charger la vue de grille.

mon implémentation - dans l'activité principale, je définirai une classe interne qui étend L'AsyncTask pour envoyer la requête HTTP dans doInBackGround Méthode et récupérer la réponse JSON et mettre à jour mon tableau local de FlickrItems que je vais utiliser pour mettre à jour mon GridView via le FlickrAdapter (étend le BaseAdapter) et appeler l'adaptateur.notifyDataSetChanged() dans l'onPostExecute () d'AsyncTask pour recharger la vue grid. Notez que la requête HTTP est ici un appel de blocage à cause duquel je l'ai fait via L'AsyncTask. Et, je peux mettre en cache les éléments dans Adaptateur pour augmenter la performance ou les stocker sur SDCard. La grille que je serai gonfler dans le FlickrAdapter contient dans mon implémentation une barre de progression et une vue d'image. Vous trouverez ci-dessous le code de mainActivity que j'ai utilisé.

la Réponse à la Question - Ainsi, une fois que nous avons les données JSON pour récupérer des Images individuelles, nous pouvons implémenter la logique d'obtenir les images en arrière-plan via des gestionnaires ou des Threads ou AsyncTask. Nous devons noter ici que mes images Une fois téléchargées doivent être affichées sur le Nous ne pouvons pas simplement utiliser les threads tels quels car ils n'ont pas accès au contexte. Dans le FlickrAdapter, les choix auxquels je pouvais penser:

• Choix 1: Créer un LooperThread [extends thread] - et de garder sur télécharger des images séquentiellement dans un fil en gardant ce fil ouvrez [looper.loop()]
• choix 2: utilisez un pool de threads et postez le runnable via myHandler qui contient des références à mon ImageView, mais depuis les vues en Grid View sont recyclés, là encore le problème pourrait se poser lorsque l'image à l'index 4 est affiché à l'index 9 [le téléchargement peut prendre plus de temps]
• choix 3 [j'ai utilisé ceci]: utilisez un Pool de threads et envoyez un message à myHandler, qui contient des données relatives à L'index D'ImageView et ImageView lui - même, donc en faisant handleMessage() nous mettrons à jour le ImageView uniquement si currentIndex correspond à l'index de l'Image essayé de le télécharger.
• choix 4: Utilisez AsyncTask pour télécharger images en arrière-plan, mais ici je n'aurai pas accès au nombre de threads que je veux dans le pool de threads et il varie avec la version android différente, mais dans le choix 3, je peux prendre la décision consciente de la taille du pool de threads en fonction de la configuration de l'appareil utilisé.

ici le code source:

public class MainActivity extends ActionBarActivity {

    GridView imageGridView;
    ArrayList<FlickrItem> items = new ArrayList<FlickrItem>();
    FlickrAdapter adapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        imageGridView = (GridView) findViewById(R.id.gridView1);
        adapter = new FlickrAdapter(this, items);
        imageGridView.setAdapter(adapter);
    }

    // To avoid a memory leak on configuration change making it a inner class
    class FlickrDownloader extends AsyncTask<Void, Void, Void> {



        @Override
        protected Void doInBackground(Void... params) {
            FlickrGetter getter = new FlickrGetter();

            ArrayList<FlickrItem> newItems = getter.fetchItems();

            // clear the existing array
            items.clear();

            // add the new items to the array
            items.addAll(newItems);

            // is this correct ? - Wrong rebuilding the list view and should not be done in background
            //adapter.notifyDataSetChanged();

            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);

            adapter.notifyDataSetChanged();
        }

    }

    public void search(View view) {
        // get the flickr data
        FlickrDownloader downloader = new FlickrDownloader();
        downloader.execute();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();
        if (id == R.id.action_settings) {
            return true;
        }
        return super.onOptionsItemSelected(item);
    }
}

j'espère que ma réponse bien que longtemps aidera à comprendre certains des détails les plus fins.

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();
    }

}

Handler - moyen de communication entre fils. Dans android, il est principalement utilisé pour communiquer avec le fil principal par la création et l'envoi de messages par handler

AsyncTask - est utilisé pour effectuer des applications de longue durée dans un thread d'arrière-plan. Avec n AsyncTask vous pouvez faire l'opération dans un thread de fond et obtenir le résultat dans le thread principal de l'application.

Thread - est un procédé léger, à obtenir la simultanéité et l'utilisation maximale du cpu. Dans android, vous pouvez utiliser le fil pour effectuer des activités qui ne touche pas L'interface utilisateur de l'application

Thread

Lorsque vous démarrez une application, un processus est créé pour exécuter le code. Pour utiliser efficacement la ressource de calcul, les threads peuvent être lancés dans le processus de sorte que plusieurs tâches peuvent être exécutées à la fois. Ainsi, les threads vous permettent de construire des applications efficaces en utilisant cpu efficacement sans temps mort.

dans Android, tous les composants s'exécutent sur un seul thread appelé main thread. Tâches de la file d'attente du système Android et exécution un par un sur le fil principal. Lorsque les tâches sont exécutées, l'application ne répond plus.

pour éviter cela, vous pouvez créer des threads de travail et exécuter des tâches de fond ou de longue durée.

Gestionnaire

puisque android utilise le modèle de thread simple, les composants UI sont créés non-thread safe signifiant seulement le thread qu'il a créé devrait y accéder ce qui signifie que le composant UI doit être mis à jour sur le thread principal seulement. Comme le composant UI tourne sur le thread principal, les tâches qui tournent sur worker threads ne peuvent pas modifier les composants UI. C'est là que Gestionnaire entre en image. Handler avec L'aide de Looper peut se connecter à un nouveau thread ou un thread existant et exécuter le code qu'il contient sur le thread connecté.

Handler rend possible la communication inter thread. En utilisant Handler, background thread peut lui envoyer des résultats et le handler qui est connecté au thread principal peut mettre à jour les composants de L'interface utilisateur. sur le thread principal.

AsyncTask

AsyncTask fourni par android utilise à la fois thread et handler pour rendre l'exécution des tâches simples en arrière-plan et la mise à jour des résultats du thread d'arrière-plan au thread principal facile.

s'il vous Plaît voir android fil, gestionnaire, asynctask et des pools de threads pour des exemples.