Différence entre AsyncTask et Thread/Runnable
J'ai une question qui m'énerve.
Imaginez que je veuille faire quelque chose dans un autre fil, comme récupérer du contenu GPS/Localisation, qui, comme recommandé dans les documents SDK, doit utiliser un fil de fond.
Alors, voici la question: Quelle est la différence entre
Créer une
Threaden arrière-plan viaAsyncTaskETCréation de
Thread thread1 = new Thread(new Runnable()... et implémentation derun()?
AsyncTask est une classe de commodité permettant de travailler sur un nouveau thread et d'utiliser les résultats sur le thread à partir duquel elle a été appelée (généralement le thread d'interface utilisateur) une fois l'opération terminée. C'est juste un wrapper qui utilise deux ou trois runnables mais gère toutes les subtilités de la création du thread et de la gestion de la messagerie entre les threads.
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 des résultats sur le thread d'interface utilisateur sans avoir à manipuler des threads et/ou des gestionnaires.
AsyncTask est conçu pour être une classe d'assistance autour de Thread and Handler et ne constitue pas un framework de threading générique. Les tâches asynchrones doivent idéalement être utilisées pour des opérations courtes (quelques secondes au maximum). Si vous devez maintenir les threads en cours d'exécution pendant de longues périodes, il est vivement recommandé d'utiliser les différentes API fournies par le paquet Java.util.concurrent telles Executor, ThreadPoolExecutor et FutureTask.
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. Une tâche asynchrone est définie par 3 types génériques, appelés Params, Progression et Résultat, et 4 étapes, appelés onPreExecute, doInBackground, onProgressUpdate et onPostExecute.
Le Runnable interface est au cœur du threading Java. L'interface Runnable doit être implémentée par toute classe dont les instances sont destinées à être exécutées par un thread.
Aussi, si je cite de ce blog :
si vous avez besoin du codage SIMPLE, utilisez AsyncTask et si vous avez besoin de SPEED, utilisez le thread Java traditionnel.
De plus, à compter du lancement d’Android v4.04, vous ne pouvez pas avoir plus d’une AsyncTasks à la fois, à moins de perdre la compatibilité avec les versions antérieures. Être conscient!
Principales différences
AsyncTask est une tâche asynchrone définie par un calcul exécuté sur un thread d'arrière-plan et dont le résultat est publié sur le thread d'interface utilisateur. Cela ne peut être fait avec un fil normal que si vous utilisez
Handlersur le fil de l'interface utilisateur et postez un message OR directement changer l'attribut d'un objet en implémentant une synchronisation correcte.Comme recommandé par le guide du développeur concernant performances du thread ,
Il faut garder à l’esprit quelques aspects importants de la performance. Premièrement, 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 mode série et, comme pour le thread principal, un paquet de travail particulièrement long peut bloquer la file d'attente. Pour cette raison, nous vous suggérons d'utiliser AsyncTask uniquement pour gérer des éléments de travail d'une durée inférieure à 5 ms.
Mais les normales Thread peuvent être utilisées pour les tâches de longue durée.
Les threads Java simples ne sont pas très utiles pour Android, contrairement à HandlerThread , fourni par le framework Android.
Classe pratique pour démarrer un nouveau thread qui a une boucle. Le boucleur peut ensuite être utilisé pour créer des classes de gestionnaires. Notez que start () doit toujours être appelé.
Reportez-vous à l'article ci-dessous pour en savoir plus:
Mieux vaut utiliser le nouveau planificateur de travaux dans la bibliothèque de support.
Un inconvénient évident pour la classe AsyncTask réside dans le fait qu'après Android 3.0, les tâches asynchrones sont exécutées en fonction de la séquence de l'heure de début. les tâches sont exécutées une par une, à moins que vous ne l'exécutiez en appelant "executeOnExecutor (Executors.newCachedThreadPool ())". cette méthode créerait votre propre pool de threads.