Introduction à cette section :

Cette section vous présente une classe légère fournie par Android pour gérer les tâches asynchrones : AsyncTask. Nous héritons généralement d'AsyncTask, puis implémentons les opérations asynchrones dans la classe, et renvoyons ensuite la progression de l'exécution asynchrone au thread principal de l'interface utilisateur~ Bon, certains concepts peuvent être flous pour tout le monde, et je pense qu'il est nécessaire d'expliquer le concept de multithreading. Commençons donc par expliquer quelques notions conceptuelles !


1. Concepts associés

1) Qu'est-ce que le multithreading :

Réponse : Tout d'abord, vous devez comprendre ces termes : application, processus, thread, multithreading !!

  • Application: Un ensemble d'instructions (un ensemble de code statique) écrit dans un certain langage pour accomplir une tâche spécifique.
  • Processus :Un programme en cours d'exécution, une unité de planification système et d'allocation de ressourcesunité indépendante, le système d'exploitation alloue une section d'espace mémoire à chaque processus ; l'exécution dynamique d'un programme passe par le processus complet de chargement du code -> exécution -> achèvement !
  • Fil d'exécution: une unité d'exécution plus petite qu'un processus. Chaque processus peut avoir plusieurs fils d'exécution.Un fil d'exécution doit être placé dans un processus pour s'exécuter !Les fils d'exécution sont gérés par le programme !!! Les processus sont ordonnancés par le système !!!
  • Concept de multithreading: exécuter plusieurs instructions en parallèle, en divisant lestranches de temps du CPUselon l'algorithme d'ordonnancement, et les allouer à chaque fil d'exécution. En fait, il s'agit d'uneexécution en temps partagé, mais le temps de commutation est très court, donc l'utilisateur a simplement l'impression que c'est simultané !

Un exemple simple :Vous êtes connecté à QQ et, tout à coup, vous voulez écouter de la musique. Devez-vous fermer QQ puis lancer un lecteur XX quelconque ? La réponse est non. Nous pouvons directement ouvrir le lecteur pour jouer de la musique pendant que QQ est toujours en cours d'exécution, n'est-ce pas ! C'est du multithreading simple. Dans le développement réel, il existe aussi de tels exemples. Par exemple, lorsqu'une application est en cours d'exécution et qu'une nouvelle version est trouvée, et que vous souhaitez mettre à jour en arrière-plan, à ce moment-là, nous créons généralement un fil d'exécution d'arrière-plan pour télécharger la nouvelle version de l'APK, mais nous pouvons toujours utiliser d'autres fonctions de l'application ! C'est un exemple d'utilisation du multithreading~

2) Concepts du synchrone et de l'asynchrone :

Réponse :Synchrone: Lorsque nous exécutons une fonction, avant d'obtenir le résultat, l'appel ne peut pas retourner ! En termes simples, vous devez attendre que la chose précédente soit terminée avant de faire la suivante. Un exemple simple : si vous avez des rapports sexuels, pour éviter une grossesse, vous devez d'abord mettre un préservatif, puis avoir des rapports sexuels, n'est-ce pas ? Préservatif mis -> puis avoir des rapports sexuels. Si vous n'avez pas de préservatif, alors l'opération sexuelle doit attendre que vous achetiez un préservatif et le mettiez, et ce n'est qu'alors que vous pourrez commencer à avoir des rapports sexuels. Un exemple vivant, ♪(^∇^*)Asynchrone: C'est l'opposé de synchrone. Après avoir exécuté une fonction, nous n'avons pas besoin d'obtenir le résultat immédiatement. Nous pouvons normalement effectuer d'autres opérations. Cette fonction peut nous notifier ou nous rappeler pour nous dire après son achèvement. En reprenant l'exemple de téléchargement en arrière-plan ci-dessus : avec le téléchargement en arrière-plan, après avoir exécuté la fonction de téléchargement, nous n'avons pas besoin de nous soucier de son processus de téléchargement ; lorsque le téléchargement est terminé, il nous le notifie simplement~

3) Pourquoi Android introduit-il des tâches asynchrones ?

Réponse : Parce que lorsqu'un programme Android démarre, il démarre simultanément un thread principal correspondant (Main Thread). Ce thread principal est principalement chargé de gérer les événements liés à l'interface utilisateur ! Parfois, nous l'appelons aussi le thread UI ! Lors du développement d'applications Android, nous devons respecter les règles de ce modèle monothread :Les opérations d'interface utilisateur Android ne sont pas thread-safe, et ces opérations doivent être exécutées dans le thread UI !Si nous sommes dans un thread non-UI, par exemple, en créant un autre thread avec new Thread() depuis le thread principal, puis en modifiant directement les valeurs des contrôles d'interface utilisateur à l'intérieur, l'exception suivante sera levée :android.view.ViewRoot$CalledFromWrongThreadException: Seul le thread d'origine qui a créé une hiérarchie de vues peut toucher ses vuesDe plus, un autre point : si nous plaçons toutes les opérations chronophages dans le thread UI, et si le thread UI ne répond pas aux demandes de l'utilisateur pendant plus de 5 secondes, alors une exception ANR (Application Not Responding) sera déclenchée, c'est-à-dire que l'application ne répond pas. Enfin, autre point : après Android 4.0, les opérations réseau sont interdites dans le thread UI ; sinon il signalera :android.os.NetworkOnMainThreadException

Toutes les raisons ci-dessus illustrent l'importance de l'introduction des tâches asynchrones par Android. Bien sûr, implémenter l'asynchrone ne nécessite pas nécessairement AsyncTask expliqué dans cette section. Nous pouvons créer nous-mêmes un thread et, après avoir terminé les opérations associées, mettre à jour l'UI via les deux méthodes suivantes :

  1. Le Handler que nous avons appris plus tôt : nous écrivons la mise à jour de l'UI dans le Handler, puis nous notifions l'UI de se mettre à jour via des méthodes telles que sendMessage(). De plus, n'oubliez pas la différence entre écrire un Handler dans le thread principal et dans un thread enfant~
  2. Utilisez Activity.runOnUiThread(Runnable) pour placer le code de mise à jour de l'UI dans un Runnable. Lors de la mise à jour de l'UI, passez simplement l'objet Runnable~

2. Analyse complète d'AsyncTask :


1) Pourquoi utiliser AsyncTask ?

Réponse : Nous pouvons utiliser les deux méthodes ci-dessus pour effectuer nos opérations asynchrones. Si les opérations asynchrones que nous devons écrire sont nombreuses ou lourdes, devons-nous encore créer un nouveau Thread() puis utiliser les méthodes ci-dessus pour notifier l'UI de se mettre à jour ? Les programmeurs aiment généralement être paresseux. Étant donné que l'équipe officielle nous a fourni AsyncTask, une classe asynchrone légère et bien encapsulée, pourquoi ne pas l'utiliser ? Nous pouvons effectuer nos opérations asynchrones avec des dizaines de lignes de code, et la progression peut être contrôlée. Comparé à Handler, AsyncTask est plus simple et plus rapide. Bien sûr, cela ne convient qu'aux opérations asynchrones simples. De plus, les endroits les plus courants où l'asynchronie est utilisée en pratique sont les opérations réseau, le chargement d'images, la transmission de données, etc. AsyncTask peut temporairement répondre aux besoins des débutants et pour l'écriture de petites applications. Mais lorsque vous entrez dans une entreprise et travaillez réellement sur des projets, nous utilisons plus souvent des frameworks tiers, tels que Volley, OkHttp, android-async-http, XUtils, et bien d'autres. Dans les tutoriels avancés ultérieurs, nous choisirons 1-2 frameworks à apprendre. Bien sûr, vous pouvez trouver des ressources pour apprendre par vous-même, mais il reste nécessaire de maîtriser AsyncTask !


2) Structure de base d'AsyncTask :

AsyncTask est une classe abstraite. Généralement, nous définissons une classe pour hériter d'AsyncTask et redéfinissons les méthodes associées. API officielle :AsyncTask

  • Paramètres pour construire une sous-classe d'AsyncTask :

  • Méthodes associées et flux d'exécution :

  • Précautions :


3. Exemples d'utilisation d'AsyncTask :

Comme nous n'avons pas encore appris la partie réseau Android, et pour ménager les débutants, nous utilisons ici un thread différé pour simuler le processus de téléchargement de fichier. Plus tard, quand nous aborderons le réseau, je vous écrirai quelques exemples supplémentaires~

Aperçu de l'effet d'implémentation :

Fichier de mise en page : activity.xml :

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    xmlns:tools="http://schemas.android.com/tools"  
    android:layout_width="match_parent"  
    android:layout_height="match_parent"  
    android:orientation="vertical"  
    tools:context=".MyActivity">  
    <TextView  
        android:id="@+id/txttitle"  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content" />  
    <!--设置一个进度条,并且设置为水平方向-->  
    <ProgressBar  
        android:layout_width="fill_parent"  
        android:layout_height="wrap_content"  
        android:id="@+id/pgbar"  
        style="?android:attr/progressBarStyleHorizontal"/>  
    <Button  
        android:layout_width="wrap_content"  
        android:layout_height="wrap_content"  
        android:id="@+id/btnupdate"  
        android:text="更新progressBar"/>  
</LinearLayout> 

Définir une opération différée pour simuler le téléchargement :

public class DelayOperator {  
    //延时操作,用来模拟下载  
    public void delay()  
    {  
        try {  
            Thread.sleep(1000);  
        }catch (InterruptedException e){  
            e.printStackTrace();;  
        }  
    }  
}

AsyncTask personnalisé :

public class MyAsyncTask extends AsyncTask<Integer,Integer,String>  
{  
    private TextView txt;  
    private ProgressBar pgbar;  
  
    public MyAsyncTask(TextView txt,ProgressBar pgbar)  
    {  
        super();  
        this.txt = txt;  
        this.pgbar = pgbar;  
    }  
  
  
    //该方法不运行在UI线程中,主要用于异步操作,通过调用publishProgress()方法  
    //触发onProgressUpdate对UI进行操作  
    @Override  
    protected String doInBackground(Integer... params) {  
        DelayOperator dop = new DelayOperator();  
        int i = 0;  
        for (i = 10;i <= 100;i+=10)  
        {  
            dop.delay();  
            publishProgress(i);  
        }  
        return  i + params[0].intValue() + "";  
    }  
  
    //该方法运行在UI线程中,可对UI控件进行设置  
    @Override  
    protected void onPreExecute() {  
        txt.setText("开始执行异步线程~");  
    }  
  
  
    //在doBackground方法中,每次调用publishProgress方法都会触发该方法  
    //运行在UI线程中,可对UI控件进行操作  
  
  
    @Override  
    protected void onProgressUpdate(Integer... values) {  
        int value = values[0];  
        pgbar.setProgress(value);  
    }  
}

MainActivity.java:

public class MyActivity extends ActionBarActivity {  
  
    private TextView txttitle;  
    private ProgressBar pgbar;  
    private Button btnupdate;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        txttitle = (TextView)findViewById(R.id.txttitle);  
        pgbar = (ProgressBar)findViewById(R.id.pgbar);  
        btnupdate = (Button)findViewById(R.id.btnupdate);  
        btnupdate.setOnClickListener(new View.OnClickListener() {  
            @Override  
            public void onClick(View v) {  
                MyAsyncTask myTask = new MyAsyncTask(txttitle,pgbar);  
                myTask.execute(1000);  
            }  
        });  
    }  
} 

Résumé de cette section :

D'accord, au début de cette section, nous avons introduit les concepts d'application, de processus, de thread, de multithreading, d'asynchrone et de synchrone ; puis nous avons expliqué pourquoi les opérations asynchrones sont introduites dans Android, et présenté l'utilisation d'AsyncTask. Bien sûr, comme mentionné ci-dessus, les opérations asynchrones sont davantage utilisées dans les opérations réseau. Plus tard, lors de l'explication des opérations réseau, cet AsyncTask sera utilisé. Restez à l'écoute ! Cette section se termine ici, merci~