Difficile de trouver un nom adéquat pour cet article.

En fait, je vais vous donner un conseil utile pour exécuter deux AsyncTasks en parallèle et qu’elles s’attendent pour continuer. Si vous ne le savez pas, les AsyncTasks sont des classes d’exécution de code en arrière-plan. Elles sont utilisées sur Android pour récupérer des données du WEB, faire des calculs, … et tout ça, sans gêner le Thread d’affichage.

De plus, vous pouvez effectuer des traitements sur le Thread d’affichage juste avant et juste après le traitement asynchrone très simplement. D’ailleurs la documentation Android privilégie l’utilisation des AsyncTasks en lieu et place des Threads.

Bon, revenons à nos moutons. Exécuter deux AsyncTasks en parallèle et attendre que les deux se terminent pour effectuer le traitement final. En fait, nous  allons lancer la seconde AsyncTasks dans le PreExecute() de la première et effectuer le traitement final dans le PostExecute de la première aussi. Nous attendrons que la seconde finisse dans le traitement asynchrone de la première afin d’éviter tout gel du Thread d’affichage.

Si vous m’avez suivi, voici le squelette java que nous devrions avoir :

private TaskA taskA;
private TaskB taskB;

class TaskA extends AsyncTask<Void, Void, Void>{

   @Override
   protected void onPreExecute(){
       // Ici, on lance notre seconde Task
       taskB = new TaskB();
       taskB.execute();
   }

   @Override
   protected Void doInBackground(Void... params){
       // Traitements asynchrones de la Task A
       // ...
       // Fin des traitements de la Task A

       // On attends le résultat de B
       try{
           taskB.get();
       } catch(ExecutionException e) {
           e.printStackTrace();
       } catch(InterruptedException e) {
           e.printStackTrace();
       }

       return null;
   }

   @Override
   protected void onPostExecute(Void result){
       // Le traitement final
       // Ici, vous êtes dans l'UI Thread
   }
}

class TaskB extends AsyncTask<Void, Void, Void>{

   @Override
   protected Void doInBackground(Void... params){
       // Traitements asynchrones de la Task B
       // ...
       // Fin des traitements de la Task B

       return null;
   }
}

La partie qui permet d’attendre que l’autre asynctask finisse est juste la fonction get() des AsyncTask. Elle évite de passer par les Threads et de faire le couple wait()/notify().

De plus elle lève certaines exceptions si jamais la tâche que vous attendez a été annulée ou a eu une erreur d’exécution entre autre. Et pour exécuter ces deux tâches vous avez juste à appeler cette ligne dans votre code :

taskA = new TaskA();
taskA.execute();

Bien entendu, vous pouvez étendre ce cas pour en effectuer X en parallèle. Je pense avoir fini ma partie conseil pour les AsyncTasks. Si vous avez des questions, suggestions, corrections, n’hésitez surtout pas à poster un commentaire pour que j’y réponde.