Problème arrêt d'AsyncTask

Bonjour à tous,

J'utilise un AsyncTask pour faire un traitement sur une image capturé à l'aide de l’appareil photo. Mon traitement se résume à un seul appel de fonction (pour information j'appel ma fonction decode(image,dimx,dimy)).

J'utilise vos tutoriels Android pour m'aider particulièrement celui-ci :
Thread, Handler , AsyncTask et fuite mémoire.

Dans ce tutoriel est expliqué que lorsque l'AsyncTask est passer dans la fonction postExecute() (c-a-d qu'il a terminer le traitement de DoInBackground()) le thread de l'AsyncTask est killer.
Sauf que voila, quand je vais dans le DDMS d'eclipse et que je regarde les threads, mon AsyncTask est encore là avec le statut wait. Et si je relance mon traitement je vais créer un autre AsyncTask sans supprimer l'ancien.

Dans le tutoriel est donné un exemple qui traite un problème de "fuite mémoire" sauf que quand je lance le programme qui est fournis par le tutoriel je me retrouve avec le même problème d'AsyncTask non arrêté et quand on relance le programme un autre AsyncTask est créé sans supprimer l'ancien.

Est-ce que c'est normal ? J'ai quelques données membres pour mon AsyncTask est-ce que sa ne serait pas sa mon problème : "mes données ne sont pas détruite donc mon AsyncTask ne peut pas se terminé ?

Je vais rechercher ce que veut dire le statut wait mais je tenais à avoir vos avis.

Merci d'avance pour vos futures réponses.

Très bonne question que je me pose aussi.
J'ai remarqué la même chose mais en utilisant le debugger : les AsyncTask restent (avec l'état running en plus) lorsque leur "exécution" est sensé être terminée.

Code:

---

Thread [<10> AsyncTask #2] (Running)

---

J'ai eu beau chercher sur le net tout le monde dis que quand DoInBackground() est terminé, le thread est killer sauf que ... ben non !

Alors il est possible que sa soit normal (pour toi les AsyncTask sont en mode running alors que moi ils sont en mode wait) mais j'aimerais bien pouvoir trouver une justification au fait de laisser vivant un AscynTask "fantôme".

L'asyncTask est censé simplifié l'utilisation des threads mais finalement si on ne peut pas l'arrêter manuellement lorsque la tâche est effectuer autant utilisé des TimerTask (pour la simplicité d'utilisation) ou directement un thread avec handler.

Je n'ai pas regardé le code des AsyncTask en détail... mais en général la construction de l'environnement nécessaire à un AsyncTask est lent (Handler, Registrations, création du thread d'execution, ...).

Il est fort à parier que tous ces objets sont "cachés" (et le même worker thread utilisé pour plusieurs async-task). Si c'est le cas, le worker-thread est un daemon qui n'empêchera donc pas l'arrêt de la JVM. Mais il se peut qu'il conserve un pointeur sur le dernier AsyncTask executé...

Dans tous les cas ce n'est pas bien grave, il n 'y a aucun "membre" qui référence le contexte, donc peu de chance d'avoir des fuites de mémoire.
Sauf en cas de surcharge, mais là, on sait ce qu'on fait.

Allez... je suis allé voir le code vu que ca me tarabustait...

Donc conformément à ce que je disais, AsyncTask est parfaitement intelligent, et crée des worker-threads (executors) à la demande, avec un "pool" d'executors....

Rien de parfaitement normal donc que les threads restent dans le coin...
Par contre, je ne comprends pas vraiment pourquoi les objets AsyncTask resteraient en mémoire.

Edit: Oups, mais non en fait vous parlez des Threads... et c'est normal qu'ils ne soient pas détruits afin d'être réutilisés si besoin...
Je rappelle que la construction d'un thread est un truc super lent (allocation de pile, préparation du garbage-collector, etc...).
Tant que les objets AsyncTask sont bien détruits, on se fiche un peu que les threads soient toujours présents....

Ok, merci pour ta réponse et les petites informations bonus =)

Merci pour ta réponse tout d'abord.

Mais si le thread reste en mémoire comment le réutilisé sans recréé un autre thread "AsyncTask" puisqu'on ne peut lancer un AsyncTask qu'une seul fois j'aimerais savoir comment serait-il possible de pouvoir réutiliser ce même thread plutôt que d'en recréé un ?

Est ce que la technique décris dans cette page qui permet de vérifier si le thread existe pour le réutiliser serait applicable dans mon problème c'est-à-dire pour un AsyncTask.

Tous les AsyncTask partagent le même pool de threads !

Donc a chaque fois que vous instanciez un AsyncTask, il va prendre un des threads déjà créés !

Encore une fois, l'objet AsyncTask ne sert que comme "pilote" de ces executors, et sont bien "oubliés" une fois la tache finie. Les threads eux restent dispo pour d'autres AsyncTask

En effet, il semblerait que lorsqu'on atteint les 5 threads "AsyncTask" l'application arrête d'en créer et doit réutiliser les anciens (je parle au conditionnel parce que les threads reste en mode wait, mais dans mon programme test je fais un traitement très légers, je vais l'alourdir).

Dés que j'en ai la certitude vous serez les premiers informé !

Merci encore pour ta réponse !

Edit : C'est bon je viens de faire le test j'ai simplement rajouter une pause de mon thread dans la fonction doInBackground() de manière à vérifier avec le DDMS que je réutilise bien mes anciens threads et c'est bien le cas une fois qu'on a créé 5 threads après avoir utilisé le dernier on réutilise le premier puis le second et ainsi de suite.

Merci encore !!!