Les raisons de l'incendie et d'oublier les instances de ASyncTask sont détaillées assez bien à Steve Prentice réponse - Toutefois, si vous êtes limité sur combien de fois vous exécutez une ASyncTask, vous êtes libre de faire ce que vous aimez, tandis que le fil est en cours d'exécution...
Mettre votre code exécutable à l'intérieur d'une boucle à l'intérieur de doInBackground() et l'utilisation simultanée de verrouillage pour déclencher chaque exécution. Vous pouvez récupérer les résultats à l'aide publishProgress()/onProgressUpdate().
Exemple:
class GetDataFromServerTask extends AsyncTask<Input, Result, Void> {
private final ReentrantLock lock = new ReentrantLock();
private final Condition tryAgain = lock.newCondition();
private volatile boolean finished = false;
@Override
protected Void doInBackground(Input... params) {
lock.lockInterruptibly();
do {
// This is the bulk of our task, request the data, and put in "result"
Result result = ....
// Return it to the activity thread using publishProgress()
publishProgress(result);
// At the end, we acquire a lock that will delay
// the next execution until runAgain() is called..
tryAgain.await();
} while(!finished);
lock.unlock();
}
@Override
protected void onProgressUpdate(Result... result)
{
// Treat this like onPostExecute(), do something with result
// This is an example...
if (result != whatWeWant && userWantsToTryAgain()) {
runAgain();
}
}
public void runAgain() {
// Call this to request data from the server again
tryAgain.signal();
}
public void terminateTask() {
// The task will only finish when we call this method
finished = true;
lock.unlock();
}
@Override
protected void onCancelled() {
// Make sure we clean up if the task is killed
terminateTask();
}
}
Bien sûr, c'est un peu plus compliqué que les usages traditionnels de l'ASyncTask, et vous donnent la possibilité d'utiliser la publishProgress() pour les réels rapports sur les progrès réalisés. Mais si la mémoire est votre préoccupation, cette approche permettra d'assurer un seul ASyncTask reste dans le tas au moment de l'exécution.
