Dans l'interface utilisateur, je souhaite effectuer des tâches en arrière-plan.Pour que j'utilise un thread séparé.Mais j'ai suggéré par d'autres de le faire en asynctask.Quelle est la principale différence entre Asynctask et Thread, dans quel scénario j'utilise Thread et Asynctask?.
Réponses
Trop de publicités?
Pour les longues ou les tâches consommatrices d'UC, il y a essentiellement deux façons de le faire: les threads Java et Android natif de l'AsyncTask.
Ni l'un est nécessairement meilleure que l'autre, mais de savoir quand utiliser chaque appel est essentielle afin de tirer parti de la performance du système à votre avantage.
Utilisation AsyncTask pour:
- Simple network opérations qui ne nécessitent pas de téléchargement d'un grand nombre de données
- Disque lié à des tâches qui pourraient prendre plus de quelques millisecondes
Utiliser les threads Java pour:
- Les opérations de réseau qui impliquent modérée à de grandes quantités de données (que ce soit le téléchargement ou le téléchargement)
- Haute CPU des tâches qui doivent être exécutées en arrière-plan
- Toutes les tâches où vous souhaitez contrôler l'utilisation du PROCESSEUR par rapport à la thread GUI
Et il y a beaucoup de bonnes ressources sur internet qui peuvent vous aider à:
http://www.vogella.com/articles/AndroidBackgroundProcessing/article.html http://www.mergeconflict.net/2012/05/java-threads-vs-android-asynctask-which.html
Tarun Varshney
Points
2164
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 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
ldce
Points
632
Fil
- Longue tâche en général
- invoquer par thread.méthode start()
- déclenchée à partir de n'importe quel thread
- fonctionne sur son propre thread
- manuel de gestion des thread/code peut devenir difficile à lire
AsyncTask
- petite tâche d'avoir à communiquer avec le thread principal
- invoquer par excute() la méthode
- déclenché à partir du thread principal
- fonctionne sur le thread de travail
- doit être exécutée et créée à partir du Thread principal
Vipul Purohit
Points
3884
Fil
Un thread est un concurrent à l'unité d'exécution. Il a sa propre pile d'appel. Il existe deux méthodes pour mettre en œuvre des threads dans les applications.
L'un est de fournir une nouvelle classe qui étend la classe Thread et surchargeant ses méthode run (). L'autre est de fournir un nouveau Thread avec un L'objet praticable lors de sa création. Un thread peut être exécuté par l' en appelant ses "démarrer" de la méthode. Vous pouvez définir la Priorité d'un thread par en appelant ses "setPriority(int)" la méthode.
Un fil peut être utilisé si vous n'avez pas d'incidence sur dans l'INTERFACE utilisateur de la partie. Pour exemple, vous êtes en appelant le service web ou télécharger des données, et après le téléchargement, vous affichant à l'écran. Ensuite, vous devez utiliser un Gestionnaire avec un Fil et cela permettra à votre application compliqué à gérer toutes les réponses à partir de Fils.
Un Gestionnaire vous permet d'envoyer et de traiter le Message et Praticable objets associé à un thread MessageQueue. Chaque thread a chaque message la file d'attente. (Comme une Liste de choses À faire), et le thread va prendre chaque message et processus jusqu'à ce que le message de la file d'attente est vide. Ainsi, lorsque le Gestionnaire communique, il donne simplement un message à l'appelant fil et il attendre pour processus.
Si vous utilisez Java threads alors vous avez besoin pour gérer les éléments suivants les exigences dans votre propre code:
La synchronisation avec le thread principal si vous publiez les résultats de l' interface utilisateur Pas de valeur par défaut pour l'annulation de la thread Aucun thread par défaut mise en commun Pas de valeur par défaut pour le traitement des modifications de configuration dans Android
AsyncTask
AsyncTask permet une utilisation facile et de le thread d'INTERFACE utilisateur. Cette classe permet d'effectuer des opérations d'arrière-plan et la publication des résultats sur le Thread de l'INTERFACE utilisateur sans avoir à manipuler les threads et/ou les gestionnaires. Un tâche asynchrone est défini par un calcul qui s'exécute sur un thread d'arrière-plan et dont le résultat est publié sur le thread d'INTERFACE utilisateur.
AsyncTask va passer par le suivant 4 étapes:
onPreExecute()
Appelée par le thread de l'INTERFACE utilisateur avant l'exécution de la tâche
doInbackground(Params..)
Appelée par le thread d'arrière-plan immédiatement après onPreExecute() fini de s'exécuter.
onProgressUpdate(Progrès..)
Appelée par le thread de l'INTERFACE utilisateur après un appel à publishProgress(le Progrès...).
onPostExecute(Suite)
Appelée par le thread de l'INTERFACE utilisateur après le calcul de fond de finitions.
Pourquoi devriez-vous utiliser AsyncTask?
Facile à utiliser pour un Thread d'INTERFACE utilisateur. (Donc, l'utiliser lorsque le thread appelant est un Thread d'INTERFACE utilisateur).
Pas besoin de manipuler des Gestionnaires.
Pour de plus amples informations, visitez Ici
