AsyncTask Classe

Définition

[Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })]
public abstract class AsyncTask : Java.Lang.Object

[<Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })>]
type AsyncTask = class
    inherit Object

Héritage

Object

JavaObject

Object

AsyncTask

Dérivé

Android.OS.AsyncTask<TParams,TProgress,TResult>

Attributs

RegisterAttribute JavaTypeParametersAttribute

Remarques

AsyncTask a été conçu pour permettre une utilisation appropriée et facile du thread d’interface utilisateur. Toutefois, le cas d’usage le plus courant était l’intégration dans l’interface utilisateur et cela entraînerait des fuites de contexte, des rappels manqués ou des blocages sur les modifications de configuration. Il a également un comportement incohérent sur différentes versions de la plateforme, avale les exceptions de doInBackground, et ne fournit pas beaucoup d’utilitaire sur l’utilisation Executordirecte de s.

AsyncTask est conçu pour être une classe d’assistance autour Thread et Handler ne constitue pas une infrastructure de threading générique. AsyncTasks doit idéalement être utilisé pour les opérations courtes (quelques secondes au maximum).) Si vous devez conserver 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 java.util.concurrent package, par Executorexemple , ThreadPoolExecutor et FutureTask.

Une tâche asynchrone est définie 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. Une tâche asynchrone est définie par 3 types génériques, appelés Params, et Progress4 étapes, appelées Result, onPreExecutedoInBackground et onProgressUpdate. onPostExecute

<div class="special reference"><h3>Developer Guides</h3>

Pour plus d’informations sur l’utilisation des tâches et des threads, consultez le guide des processus et des threads pour les développeurs.

<Commande /div>

<Utilisation> h2</h2>

AsyncTask doit être sous-classé pour être utilisé. La sous-classe remplacera au moins une méthode (#doInBackground), et la plupart du temps remplacera une seconde (#onPostExecute.)

Voici un exemple de sous-classe :

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
                protected Long doInBackground(URL... urls) {
                    int count = urls.length;
                    long totalSize = 0;
                    for (int i = 0; i < count; i++) {
                        totalSize += Downloader.downloadFile(urls[i]);
                        publishProgress((int) ((i / (float) count) * 100));
                        // Escape early if cancel() is called
                        if (isCancelled()) break;
                    }
                    return totalSize;
                }

                protected void onProgressUpdate(Integer... progress) {
                    setProgressPercent(progress[0]);
                }

                protected void onPostExecute(Long result) {
                    showDialog("Downloaded " + result + " bytes");
                }
            }

Une fois créée, une tâche est exécutée très simplement :

new DownloadFilesTask().execute(url1, url2, url3);

<Types> génériques d’AsyncTask h2<>

Les trois types utilisés par une tâche asynchrone sont les suivants :

<ol><li>Params, le type des paramètres envoyés à la tâche lors de l’exécution.</li li><>Progress, le type des unités de progression publiées pendant le calcul en arrière-plan.</li li><>Result, le type du résultat du calcul en arrière-plan.</li></ol>

Tous les types ne sont pas toujours utilisés par une tâche asynchrone. Pour marquer un type comme inutilisé, utilisez simplement le type Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

<h2>Les 4 étapes</h2>

Lorsqu’une tâche asynchrone est exécutée, la tâche passe par 4 étapes :

<ol><li>#onPreExecute(), appelé sur le thread d’interface utilisateur avant l’exécution de la tâche. Cette étape est normalement utilisée pour configurer la tâche, par exemple en affichant une barre de progression dans l’interface utilisateur.</li li><>#doInBackground, appelé sur le thread d’arrière-plan immédiatement après #onPreExecute() l’exécution. Cette étape est utilisée pour effectuer un calcul en arrière-plan qui peut prendre beaucoup de temps. Les paramètres de la tâche asynchrone sont passés à cette étape. Le résultat du calcul doit être retourné par cette étape et sera repassé à la dernière étape. Cette étape peut également être utilisée #publishProgress pour publier une ou plusieurs unités de progression. Ces valeurs sont publiées sur le thread d’interface utilisateur, à l’étape#onProgressUpdate.</li li><>#onProgressUpdate, appelé sur le thread d’interface utilisateur après un appel à .#publishProgress Le minutage de l’exécution n’est pas défini. Cette méthode est utilisée pour afficher toute forme de progression dans l’interface utilisateur pendant que le calcul en arrière-plan est toujours en cours d’exécution. Par exemple, il peut être utilisé pour animer une barre de progression ou afficher les journaux d’activité dans un champ de texte.</li li><>#onPostExecute, appelé sur le thread d’interface utilisateur une fois le calcul en arrière-plan terminé. Le résultat du calcul en arrière-plan est passé à cette étape en tant que paramètre.</li></ol>

<h2>Annulation d’une tâche</h2>

Une tâche peut être annulée à tout moment en appelant #cancel(boolean). L’appel de cette méthode entraîne le #isCancelled() retour de true par les appels suivants. Après l’appel de cette méthode, #onCancelled(Object)au lieu d’être #onPostExecute(Object) appelé après #doInBackground(Object[]) retour. Pour vous assurer qu’une tâche est annulée le plus rapidement possible, vous devez toujours vérifier la valeur de retour à partir #isCancelled()de #doInBackground(Object[]) , si possible (à l’intérieur d’une boucle par exemple).)

<Règles> de thread h2</h2>

Il existe quelques règles de thread qui doivent être suivies pour que cette classe fonctionne correctement :

<ul><li>La classe AsyncTask doit être chargée sur le thread d’interface utilisateur. Cette opération est effectuée automatiquement à partir de android.os.Build.VERSION_CODES#JELLY_BEAN.</li li><>L’instance de tâche doit être créée sur le thread d’interface utilisateur.</li li><>#execute doit être appelé sur le thread d’interface utilisateur.</li li><>Ne pas appeler #onPreExecute(), #onPostExecute, #doInBackground, #onProgressUpdate manuellement.</li li><>La tâche ne peut être exécutée qu’une seule fois (une exception est levée si une deuxième exécution est tentée.)</li></ul>

<observabilité> de la mémoire h2</h2>

AsyncTask garantit que tous les appels de rappel sont synchronisés pour garantir les opérations suivantes sans synchronisations explicites.

<ul><li>Les effets de mémoire de #onPreExecute, et tout autre chose exécuté avant l’appel à #execute, y compris la construction de l’objet AsyncTask, sont visibles par #doInBackground. <li>Les effets de la mémoire de #doInBackground sont visibles par #onPostExecute. <li>Tous les effets de #doInBackground la mémoire précédant un appel sont #publishProgress visibles par l’appel correspondant #onProgressUpdate . (Mais #doInBackground continue à s’exécuter, et vous devez prendre soin que les mises à jour ultérieures dans #doInBackground n’interfèrent pas avec un appel en cours #onProgressUpdate .) <Li>Tous les effets de mémoire précédant un appel #cancel sont visibles après un appel à #isCancelled qui retourne true en conséquence, ou pendant et après un appel obtenu à #onCancelled. </ul>

<h2>Ordre d’exécution</h2>

Lors de la première introduction, les AsyncTasks ont été exécutés en série sur un thread d’arrière-plan unique. À compter de android.os.Build.VERSION_CODES#DONUT, cela a été remplacé par un pool de threads permettant à plusieurs tâches de fonctionner en parallèle. À compter de android.os.Build.VERSION_CODES#HONEYCOMB, les tâches sont exécutées sur un thread unique pour éviter les erreurs courantes d’application provoquées par l’exécution parallèle.

Si vous souhaitez vraiment l’exécution parallèle, vous pouvez appeler #executeOnExecutor(java.util.concurrent.Executor, Object[]) avec #THREAD_POOL_EXECUTOR.

Ce membre est déconseillé. Utilisez plutôt les utilitaires de concurrence Standard java.util.concurrent ou Kotlin .

Java documentation pour android.os.AsyncTask.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.