Comment gérer efficacement plusieurs tâches asynchrones dans Android

J'ai scénario où j'aurai à faire six http appels sur mon serveur afin d'obtenir les données pour les six éléments différents. Ces appels au serveur ne peut pas être combiné et ils sont destinés à être de cette façon. Par exemple: Si vous avez besoin de devis pour info GOOGLE, puis envoyer une demande au serveur pour demander à google de devis info. Suivant si vous avez besoin de yahoo puis vous lancer un autre appel http et ainsi de suite.

Voici la situation:

  1. Maintenant mon utilisateur final qui souhaite comparer les 6 entreprises différentes.
  2. Comme je l'ai mentionné son non-évitable pour moi de faire 6 http appels pour qui je le fais à l'aide de 6 Async Tâches.
  3. Que je reçois chaque Async task réponse, je vais rafraîchir l'INTERFACE utilisateur avec de nouvelles données.
  4. Sa mauvaise expérience d'INTERFACE utilisateur si j'ai d'actualisation de l'INTERFACE utilisateur 6 fois dans un laps de temps très court.
  5. Sa donne un effet scintillant à mon INTERFACE qui n'est pas souhaité.

Ma Question:

  1. Comment je peux tenir de l'actualisation de l'INTERFACE utilisateur jusqu'à ce que je reçois tous les 6 Async Task réponses?
  2. Je comprends chaque tâche est indépendants les uns des autres. Dois-je exécuter une boucle while et attendre jusqu'à ce que je reçois toutes les réponses?
  3. Est-il une meilleure façon de le faire plutôt que d'une boucle while, car si l'une quelconque de l'appel ne répond pas alors je vais bloqué en attente pour toujours.

Remarque: je suppose que Android 1.6+ faire exécuter Async tâches en parallèle.

C'est plus une question de conception et je vous serais reconnaissant de toute aide sur ce.

Merci d'avance

source d'informationauteur AKh | 2012-02-10

  1. 4

    Vous pourriez faire un AsyncTask piscine objet qui permet d'usurper l'identité d'un " lot " http appel.

    1. créer une collection Observable de AsyncTasks, je vais consulter cette collection comme l'eau de votre Piscine
    2. votre Activité crée la AsyncTasks (mais pas exécuter encore) et les ajoute à la Piscine
    3. Activité s'inscrit comme un observateur de la Piscine
    4. Activité raconte Piscine à exécuter, Piscine appelle à son tour exécuter sur chacun de ses Tâches
    5. Lorsque les tâches sont terminées (pour succès et échec), ils stockent les données de réponse dans la Piscine et le Pool des marques de la Tâche comme étant "complet"
    6. Une fois que toutes les Tâches sont marquées comme terminées, Piscine, notifie à l'Activité d'écoute et de

    Idée générale est de la Piscine pour savoir combien de Tâches et dans l'attente, et pour stocker les données agrégées des appels effectués. Une fois que tous sont finis, notifier à l'observation de l'Activité et de transmettre toutes les données.

    Vous aurez à travailler sur la façon de la AsyncTasks dire de la Piscine qu'ils sont finis. Peut-être tout simplement de mise en œuvre de AsyncTask qui prend une Piscine sur son constructeur de sorte que les Tâches ont une référence à la Piscine.

  2. 1

    Il existe de nombreuses façons que vous pourrait gérer:

    • Un autre AsyncTask qui regroupe les réponses de la gestion du réseau.
    • Effectuer une sendEmptyMessageDelayed() chaque, dire, 500ms à un Handler créé par votre Activity qui actualise les données qui viennent dans le réseau de tâches et continue de le faire jusqu'à ce que l'ensemble de la mise en réseau des résultats sont traitées.
    • Un Thread qui effectue l'agrégation.

    Été moi, je serais probablement aller avec le Handler. Pour résumer, le réseau des tâches de stocker les données dans certains intermédiaires de stockage. Envoyer des messages retardés à un gestionnaire, et, à l'intérieur de la handleMessage() vérifier les données dans le stockage intermédiaire et de post-mise à jour des résultats. Si il y a des résultats remarquables, post le message retardé de nouveau.

  3. 1

    J'ai trouvé cette solution plus appropriée à mon problème.
    Ce lien décrit un couple de façons de l'établissement.
    1. ExecutorService
    2. ExecutoreService et CountDownLatch

    ExecutoreService et CountDownLatch

  4. 1

    juste en coup de poignard dans le noir ici, mais vous avez:

    • 1x principal thread d'INTERFACE utilisateur
    • 6x fond asynchtasks qui ont: 6x méthodes d'exécuter en arrière-plan
      6x méthodes pour renvoyer les données à l'INTERFACE utilisateur (au premier plan)

    pourquoi ne pas avoir une variable de portée publique dans le thread d'INTERFACE utilisateur-dire appelé "finishedTasks", puis la même méthode dans chaque 6x retour des données de threads:

    • incréments finishedTasks

    • si finishedTasks == 6 puis exécutez 1 méthode publique pour faire la mise à jour de l'INTERFACE utilisateur

    ensuite, il serait de mise à jour de l'INTERFACE utilisateur sur tous les documents de asychtasks remplir.