Asynctask vs Thread dans android
Dans l'interface utilisateur, pour effectuer certains travaux de base, j'ai utilisé un Thread séparé. Mais comme suggéré par d'autres, j'utilise maintenant AsyncTask.
Quelle est la principale différence entre un Thread et un AsyncTask?
Dans quel scénario dois-je utiliser un Thread ou un AsyncTask?
Pour les tâches de longue durée ou gourmandes en ressources processeur, il existe essentiellement deux façons de procéder: les threads Java et la tâche AsyncTask native d'Android.
Aucun des deux n'est nécessairement meilleur que l'autre, mais il est essentiel de savoir quand utiliser chaque appel pour optimiser les performances du système.
Utilisez AsyncTask pour:
- Opérations réseau simples ne nécessitant pas de télécharger beaucoup de données
- Tâches liées au disque pouvant prendre plus que quelques millisecondes
Utilisez les discussions Java pour:
- Opérations réseau impliquant des quantités de données modérées à importantes (téléchargement ou téléchargement)
- Tâches à processeur élevé devant être exécutées en arrière-plan
- Toute tâche pour laquelle vous souhaitez contrôler l'utilisation du processeur par rapport au thread d'interface graphique
Et il y a beaucoup de bonnes ressources sur Internet qui peuvent vous aider:
http://www.vogella.com/articles/AndroidBackgroundProcessing/article.html
Si vous utilisez les threads Java, vous devez gérer les exigences suivantes dans votre propre code:
Synchronisation avec le fil principal si vous publiez des résultats en retour sur l'interface utilisateur
Pas de défaut pour annuler le fil
Pas de pool de threads par défaut
Pas de valeur par défaut pour gérer les changements de configuration dans Android
Fil
- longue tâche en général
- Invoquer par la méthode thread.start ()
- Déclenché à partir de n'importe quel thread
- Fonctionne sur son propre thread
- La gestion manuelle du fil/code peut devenir difficile à lire
AsyncTask
- Petite tâche avoir à communiquer avec le thread principal
- Invoquer par la méthode excute ()
- Déclenché à partir de thread principal
- S'exécute sur thread de travail
- Doit être exécuté et créé à partir du thread principal
Fil de discussion
Un thread est une unité d'exécution simultanée. Il a sa propre pile d'appels. Il existe deux méthodes pour implémenter des threads dans les applications.
L'une fournit une nouvelle classe qui étend Thread et redéfinit sa méthode run (). L'autre fournit une nouvelle instance de Thread avec un objet Runnable lors de sa création. Un thread peut être exécuté en appelant sa méthode "start". Vous pouvez définir la "priorité" d'un thread en appelant sa méthode "setPriority (int)".
Un thread peut être utilisé si vous n'avez aucun effet dans la partie interface utilisateur. Par exemple, vous appelez un service Web ou téléchargez des données et, après le téléchargement, vous les affichez sur votre écran. Ensuite, vous devez utiliser un gestionnaire avec un thread, ce qui rendra votre application compliquée à gérer toutes les réponses de thread.
Un gestionnaire vous permet d’envoyer et de traiter les objets Message et Runnable associés au MessageQueue d’un thread. Chaque thread a chaque file de messages. (Comme une liste de tâches), et le fil prendra chaque message et le traitera jusqu'à ce que la file de messages soit vide. Ainsi, lorsque le gestionnaire communique, il envoie simplement un message au thread appelant et il attendra d'être traité.
Si vous utilisez des threads Java, vous devez gérer les exigences suivantes dans votre propre code:
Synchronisation avec le fil principal si vous publiez des résultats dans l'interface utilisateur Pas de valeur par défaut pour annuler le fil Pas de pool de fils par défaut Pas de valeur par défaut pour la gestion des modifications de configuration dans Android
AsyncTask
AsyncTask permet d'utiliser correctement et facilement le thread d'interface utilisateur. Cette classe permet d'effectuer des opérations en arrière-plan et de publier les résultats sur le thread d'interface utilisateur sans avoir à manipuler les threads et/ou les gestionnaires. Une tâche asynchrone est définie par un calcul qui s'exécute sur un thread en arrière-plan et dont le résultat est publié sur le thread d'interface utilisateur.
AsyncTask passera par les 4 étapes suivantes:
onPreExecute ()
Invoqué sur le thread d'interface utilisateur avant l'exécution de la tâche
doInbackground (Params ..)
Invoqué sur le thread d'arrière-plan immédiatement après l'exécution de onPreExecute ().
onProgressUpdate (Progress ..)
Invoqué sur le thread d'interface utilisateur après un appel à publishProgress (Progress ...).
onPostExecute (Résultat)
Invoqué sur le thread d'interface utilisateur une fois le calcul d'arrière-plan terminé.
Pourquoi devriez-vous utiliser AsyncTask?
Facile à utiliser pour un thread d'interface utilisateur. (Donc, utilisez-le lorsque le fil de l'appelant est un fil de l'interface utilisateur).
Pas besoin de manipuler les gestionnaires.
Pour plus d'informations, visitez le site Here
Sujet de discussion:
Thread doit être utilisé pour séparer les opérations longues du thread principal afin d'améliorer les performances. Mais cela ne peut pas être annulé avec élégance et il ne peut pas gérer les changements de configuration d'Android. Vous ne pouvez pas mettre à jour l'interface utilisateur à partir de Thread.
AsyncTask peut être utilisé pour gérer des tâches ayant une durée inférieure à 5 ms. Avec AsyncTask, vous pouvez mettre à jour l'interface utilisateur contrairement à Java Thread. Mais de nombreuses tâches de longue durée vont étouffer la performance.
Vous avez peu d'alternatives aux deux.
HandlerThread / Gestionnaire et ThreadPoolExecutor
Reportez-vous à l'article ci-dessous pour plus de détails: