Les raisons pour lesquelles les instances d'ASyncTask fire-and-forget sont assez bien détaillées dans la réponse de Steve Prentice - Cependant, même si vous êtes limité sur le nombre de fois que vous exécutez une ASyncTask, vous êtes libre de faire ce que vous voulez pendant que le thread est en cours d'exécution. .
Placez votre code exécutable dans une boucle dans doInBackground () et utilisez un verrou simultané pour déclencher chaque exécution. Vous pouvez récupérer les résultats à l'aide de 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, cela est légèrement plus compliqué que l'utilisation traditionnelle d'ASyncTask, et vous abandonnez l'utilisation de publishProgress () pour les rapports d'avancement réels. Mais si la mémoire est votre préoccupation, cette approche garantira qu'une seule ASyncTask reste dans le tas au moment de l'exécution.