Tâche asynchrone AnsyncTask


Introduction à cette section :

Ce que cette section vous apporte est une classe légère fournie par Android pour gérer les tâches asynchrones : AsyncTask, nous avons habituellement Héritez d'AsyncTask, puis implémentez les opérations asynchrones dans la classe, puis retournez la progression de l'exécution asynchrone au thread principal de l'interface utilisateur ~ Bon, peut-être que vous ne comprenez pas certains concepts, et je pense qu'il est quand même nécessaire d'expliquer le concept de multi-threading, alors expliquons d'abord quelques choses conceptuelles !

1. Concepts associés

1) Qu'est-ce que le multi-threading :

Réponse : Vous devez d'abord comprendre ces noms : application, processus, Threads. , multi-threads ! !

  • Application (Application)  : Un ensemble d'instructions (un ensemble de codes statiques) écrites dans une certaine langue pour accomplir une tâche spécifique
  • Processus :Un programme en cours d'exécution, une unité indépendante de planification du système et d'allocation de ressources, le système d'exploitation l'attribuera à chaque processus Une section d'espace mémoire, le programme est exécuté dynamiquement de manière séquentielle, le code du gestionnaire est chargé -> exécuté ->
  • Thread : Une unité d'exécution plus petite qu'un processus. Chaque processus peut avoir plusieurs threads Les threads doivent être placés dans un seul processus pour s'exécuter ! Les fils de discussion sont gérés par le programme ! ! ! Le processus est planifié par le système ! ! !
  • Multithreading : Exécutez plusieurs instructions en parallèle et allouez la tranche de temps du CPU à chaque thread selon l'algorithme de planification. En fait, c'estTime-. partage de l'exécution, mais le temps de commutation est très court, et l'utilisateur le sent en même temps !

Un exemple simple : Vous raccrochez QQ et souhaitez soudainement écouter de la musique. Avez-vous besoin d'éteindre QQ puis de démarrer le lecteur XX ? La réponse est non, ouvrons directement le lecteur Jouez simplement des chansons, QQ fonctionne toujours, n'est-ce pas ? Il s'agit d'un simple multithread ~ Dans le développement réel, il existe également des exemples tels que l'application est en cours d'exécution, Nous avons trouvé une nouvelle version et souhaitons la mettre à jour en arrière-plan. À ce stade, nous ouvrons généralement un fil de discussion en arrière-plan pour télécharger la nouvelle version d'apk, mais pour le moment. Nous pouvons également utiliser d'autres fonctionnalités de l'application ! Ceci est un exemple d'utilisation du multi-threading~

2) Le concept de synchronisation et d'asynchronisme :

Réponse : Synchronisation : Lorsque nous exécutons une certaine fonction, l'appel ne peut pas revenir avant d'obtenir le résultat ! Pour faire simple, cela signifie qu'il faut Attendez que l'étape précédente soit terminée avant de pouvoir passer à l'étape suivante ; pour donner un exemple simple : si vous avez des relations sexuelles, pour éviter de tuer quelqu'un, vous devez d'abord mettre un préservatif. Alors faites l'amour, n'est-ce pas ? Mettez le préservatif -> Ensuite, faites l'amour. Par exemple, si vous n'avez pas de préservatif, vous devez attendre de mettre le préservatif. Après avoir acheté le préservatif et l'avoir apporté avec vous, vous pouvez commencer à avoir des relations sexuelles à ce moment-là ~ Un exemple frappant, ♪(^∇^*)Asynchrone : C'est relatif au synchrone. fonction , nous n'avons pas besoin d'obtenir le résultat immédiatement, nous pouvons normalement Pour effectuer d'autres opérations, cette fonction peut nous avertir ou rappeler une fois terminée ou l'exemple de téléchargement en arrière-plan ci-dessus, 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. Nous pouvons simplement nous avertir lorsque le téléchargement est terminé ~

3) Pourquoi Android devrait-il introduire des tâches asynchrones

Réponse : Car lors du premier démarrage du programme Android, un thread principal correspondant (Main Thread) sera démarré en même temps. Ce thread principal est principalement responsable du traitement. Événements liés à l'interface utilisateur ! Parfois, nous l'appelons aussi le fil de discussion de l'interface utilisateur ! Dans l'application Android, nous devons respecter les règles de ce modèle monothread : Les opérations de l'interface utilisateur Android ne sont pas thread-safe et ces opérations doivent être exécutées dans le thread de l'interface utilisateur ! Si nous sommes dans un thread non-UI, comme new Thread() dans le thread principal, créez un autre thread, puis modifiez la valeur du contrôle UI directement dans celui-ci ; À ce stade, 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, il y a un autre point, si nous prenons tous les opérations fastidieuses S'il est placé dans le thread UI, si le thread UI ne répond pas à la demande pendant plus de 5 s, alors A ce moment, une exception ANR (Application Not Responding) sera déclenchée, ce qui signifie que l'application ne répond pas ~ La dernière chose est : après Android 4.0, il est interdit d'effectuer des opérations réseau dans le thread de l'interface utilisateur ~ sinon il signalera : android.os.NetworkOnMainThreadException

Toutes les raisons ci-dessus Expliquer Android L'importance de l'introduction de tâches asynchrones, bien sûr, n'est pas nécessaire pour implémenter des tâches asynchrones sans notre explication dans cette section. AsyncTask, nous pouvons ouvrir un fil nous-mêmes. Après avoir terminé les opérations pertinentes, nous pouvons mettre à jour l'interface utilisateur via les deux méthodes suivantes :

  1. Le gestionnaire que nous avons appris plus tôt, nous écrivons la mise à jour de l'interface utilisateur dans le gestionnaire, puis notifions l'interface utilisateur via des méthodes telles que sendMessage() Mise à jour, n'oubliez pas la différence entre le gestionnaire écrit dans le thread principal et le sous-thread ~
  2. Utilisez Activity.runOnUiThread(Runnable) pour créer le code de mise à jour de l'interface utilisateur dans Runnable. Lors de la mise à jour de l'interface utilisateur, mettez Runnable. Passez simplement l'objet dans~

2. Analyse complète d'AsyncTask :

1) Pourquoi utiliser AsyncTask ?

Réponse : Nous pouvons utiliser les deux méthodes ci-dessus pour terminer nos opérations asynchrones. L'ajout d'opérations asynchrones nous oblige à écrire plus ou est plus fastidieux. Devrions-nous créer un nouveau Thread(), puis utiliser la méthode ci-dessus pour informer l'interface utilisateur des mises à jour ? Les programmeurs ont tendance à être paresseux depuis le fonctionnaire. Nous fournissons AsyncTask, une classe asynchrone légère encapsulée, pourquoi ne pas l'utiliser ? Nous pouvons le faire avec des dizaines de lignes de code Notre fonctionnement asynchrone et la progression sont contrôlables ; par rapport à Handler, AsyncTask est plus simple et plus rapide ~ Bien sûr, cela ne convient que pour Opérations asynchrones simples De plus, les opérations asynchrones les plus couramment utilisées sont les opérations réseau, le chargement d'images, la transmission de données, etc. AsyncTask. Cela peut répondre aux besoins des débutants pour le moment. Merci pour la petite application. Mais une fois que l'entreprise aura réellement réalisé des projets, nous utiliserons davantage des projets tiers. Il existe de nombreux frameworks, tels que Volley, OkHttp, android-async-http, XUtils, etc. Nous choisirons plus tard 1 à 2 frameworks pour les didacticiels avancés. Apprendre, bien sûr vous pouvez trouver du matériel pour apprendre par vous-même, mais encore faut-il maîtriser AsyncTask !

2) La structure de base d'AsyncTask


AsyncTask est une classe abstraite Généralement, nous définirons une classe pour hériter d'AsyncTask puis la remplacer. méthodes associées ~ API officielle : AsyncTask

  • Paramètres pour créer la sous-classe AsyncTask :

1.jpg

  • Méthodes et processus d'exécution associés :

2.jpg

  • Remarques :

3.jpg

3. Exemple d'utilisation d'AsyncTask :

Parce que nous n'avons pas encore appris Android. pour le réseau, je m'occuperai de tous les débutants ici, et j'utiliserai le delay ici. Fils de discussion pour simuler le processus de téléchargement de fichiers~ J'écrirai quelques exemples pour vous lorsque je parlerai du réseau plus tard~

Rendu d'implémentation :

4.gif

Fichier de mise en page : activité.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"/>  
    <Bouton   
        android:layout_width="wrap_content"   
        android:layout_height="wrap_content"   
        android:id="@+id/btnupdate"  
        android:text="更新progressBar "/>  
</LinearLayout>

Définir une opération de retard, utilisée pour simuler les téléchargements :

public class DelayOperator {
//Opération de retard, utilisée pour simuler les téléchargements
public void delay ()
{
try {
Thread.sleep(1000);
}catch (InterruptedException e){
e .printStackTrace();;
}  
}
}

Tâche Async personnalisée :

classe publique MyAsyncTask étend AsyncTask<Integer,Integer,String>
{
private TextView txt;
private ProgressBar pgbar; )
                                                        🎜> // Cette méthode ne s'exécute pas dans le thread de l'interface utilisateur, elle est principalement utilisée pour les opérations asynchrones. En appelant la méthode submitProgress()
// déclenche onProgressUpdate pour faire fonctionner l'interface utilisateur <. 🎜> @Override
protected String doInBackground(Integer... params) {
DelayOperator dop = new DelayOperator();
int i = 0; for (i = 10;i <= 100;i+= 10)
{
dop.de lay();
publiprogress (i);
}
Return I+Params [0] .InTValue ()+""
}

// Paramètres de contrôle
@Override
protected void onPreExecute() {
txt.setText("Démarrer l'exécution du thread asynchrone~");
}


/ /indoBackground Dans la méthode, la méthode sera déclenchée à chaque fois que la méthode publiProgress est appelée
// En cours d'exécution dans le thread de l'interface utilisateur, vous pouvez utiliser les contrôles de l'interface utilisateur


@. Remplacer
protected void onProgressUpdate(Integer.. . valeurs) {
        int valeur = valeurs[0] ;  
        pgbar.setProgress(value);  
    }  
}

MainActivity.java：

classe publique MyActivity étend ActionBarActivity {  
  
    private TextView titre txt ;  
    privée ProgressBar pgbar ;  
    Bouton privé 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 = (Bouton)findViewById(R.id.btnupdate);  
        btnupdate.setOnClickListener(new View.OnClickListener() {  
           @Override   
            public void onClick(View v) {  
                MyAsyncTask myTask = new MyAsyncTask(txttitle,pgbar);  
                myTask.execute (1000);  
            }  
        } );  
    }  
}

本节小结：

好的，本节一开始给大家普及了下应用程序，进程，线程，多线程，异步，同步的概念；接着又讲解 Pour Android, il s'agit d'AsyncTask et d'applications Android. AsyncTask，敬请期待~本节就到这里，谢谢~