Führen Sie AsyncTask mehrmals aus

In meiner Aktivität verwende ich eine Klasse, die sich von AsyncTask erstreckt, und einen Parameter, der eine Instanz dieser AsyncTask ist. Wenn ich anrufe, ist mInstanceOfAT.execute("")alles in Ordnung. Die App stürzt jedoch ab, wenn ich eine Aktualisierungstaste drücke, die die AsyncTask erneut aufruft (falls der Netzwerkjob nicht funktioniert hat). Ursache erscheint dann eine Ausnahme, die besagt

Aufgabe kann nicht ausgeführt werden: Die Aufgabe wurde bereits ausgeführt (eine Aufgabe kann nur einmal ausgeführt werden).

Ich habe versucht, cancel (true) für die Instanz der Asyctask aufzurufen, aber es funktioniert auch nicht. Die einzige Lösung besteht bisher darin, neue Instanzen der Asyntask zu erstellen. Ist das der richtige Weg?

Vielen Dank.

AsyncTask Instanzen können nur einmal verwendet werden.

Nennen Sie stattdessen einfach Ihre Aufgabe wie new MyAsyncTask().execute("");

Aus den AsyncTask-API-Dokumenten:

Threading-Regeln

Es gibt einige Threading-Regeln, die befolgt werden müssen, damit diese Klasse ordnungsgemäß funktioniert:

• Die Aufgabeninstanz muss im UI-Thread erstellt werden.
• execute (Params ...) muss im UI-Thread aufgerufen werden.
• Rufen Sie onPreExecute (), onPostExecute (Ergebnis), doInBackground (Params ...) und onProgressUpdate (Progress ...) nicht manuell auf.
• Die Aufgabe kann nur einmal ausgeführt werden (eine Ausnahme wird ausgelöst, wenn eine zweite Ausführung versucht wird.)

Die Gründe für Fire-and-Forget-Instanzen von ASyncTask sind in Steve Prentices Antwort ziemlich detailliert beschrieben. Obwohl Sie sich darauf beschränken, wie oft Sie eine ASyncTask ausführen, können Sie tun, was Sie möchten, während der Thread ausgeführt wird. .

Fügen Sie Ihren ausführbaren Code in eine Schleife in doInBackground () ein und verwenden Sie eine gleichzeitige Sperre, um jede Ausführung auszulösen. Sie können die Ergebnisse mit PublishProgress () / onProgressUpdate () abrufen .

Beispiel:

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();
    }
}

Dies ist natürlich etwas komplizierter als die herkömmliche Verwendung von ASyncTask, und Sie geben die Verwendung von PublishProgress () für die tatsächliche Fortschrittsberichterstattung auf. Wenn der Speicher jedoch Ihr Anliegen ist, stellt dieser Ansatz sicher, dass zur Laufzeit nur eine ASyncTask im Heap verbleibt.

Ich hatte das gleiche Problem. In meinem Fall habe ich eine Aufgabe, die ich in onCreate()und in erledigen möchte onResume(. Also habe ich meine Asynctask statisch gemacht und die Instanz daraus abgerufen. Jetzt haben wir immer noch das gleiche Problem.

Was ich in onPostExecute () getan habe, ist Folgendes:

instance = null;

Denken Sie daran, dass ich in der statischen Methode getInstance einchecke, dass meine Instanz nicht null ist, sonst erstelle ich sie:

if (instance == null){
    instance = new Task();
}
return instance;

Die Methode in postExecute leert die Instanz und erstellt sie neu. Dies kann natürlich auch außerhalb der Klasse erfolgen.

Ich habe meine Rotationsaufgaben statisch gemacht, wodurch ich sie bei Rotationsänderungen an UI-Threads anhängen, trennen und wieder anhängen konnte. Um jedoch auf Ihre Frage zurückzukommen, erstelle ich ein Flag, um festzustellen, ob der Thread ausgeführt wird. Wenn Sie den Thread neu starten möchten, überprüfe ich, ob die Rotationsaufgabe ausgeführt wird, wenn ich auf eine Warnung stoße. Wenn dies nicht der Fall ist, mache ich es null und erstelle dann ein neues, das den angezeigten Fehler umgeht. Außerdem habe ich nach erfolgreichem Abschluss die abgeschlossene rotationsbewusste Aufgabe auf Null gesetzt, damit sie wieder einsatzbereit ist.

Ja, es ist wahr, der Doc sagt, dass nur eine Asyntask ausgeführt werden kann.

Jedes Mal, wenn Sie es verwenden müssen, müssen Sie Folgendes tun:

// Any time if you need to call her
final FirmwareDownload fDownload = new FirmwareDownload();
fDownload.execute("your parameter");

static class FirmwareDownload extends AsyncTask<String, String, String> {
}