Abbrechen AsyncTask nach einiger Zeit

Könnte dies eine doppelte Frage, aber ich fand nicht was ich suchte.
Ich rufe einen AsyncTask in der UI-Aktivität new LoadData().execute(); und in doInBackground rufe ich eine Methode, die Zeit braucht. Ich will unterbrechen diesen thread, wenn die Daten nicht wieder nach einiger Zeit.
Unten ist der code, wie ich versuchte, dies zu tun.

class LoadData extends AsyncTask<String, String, String>
{
    @Override
    protected void onPreExecute() {
    super.onPreExecute();
    startTime = System.currentTimeMillis();
    }
    protected String doInBackground(String... args)
    {

        DataCollector dc = new DataCollector();
        data = dc.collectData(query);
        //Here I check if the time is greater than 30 seconds then cancel
        if(((System.currentTimeMillis()-startTime)/1000)>30)
        {
           cancel(true);
        }
    return null;
    }
}

Aber das bedeutet nicht aufhören, die Aufgabe nach 30 Sekunden, in der Tat ist es mehr Zeit nehmen.
Ich habe versucht get(long timeout, TimeUnit unit); als gut, aber dass funktioniert auch nicht.

Kann jemand mir zeigen, wie kann ich es machen, oder wie verwende ich isCancelled() in doInBackground.

Dank.

Vielleicht ist diese Antwort hilft dir: stackoverflow.com/a/11191070/3307066.

InformationsquelleAutor AL̲̳I | 2013-06-26

11

Benötigen Sie einen thread, der bricht die Aufgabe nach einer gewissen Zeit. Dieser Thread könnte so Aussehen:
```
public class TaskCanceler implements Runnable{
    private AsyncTask task;

    public TaskCanceler(AsyncTask task) {
        this.task = task;
    }

     @Override
     public void run() {
        if (task.getStatus() == AsyncTask.Status.RUNNING )
            task.cancel(true);
     }
}
```
Und wenn Sie rufen Sie Ihren AsyncTask, die Sie benötigen, um ausführen die absagen Aufgabe nach einer gewissen Zeit (=das Zeitlimit (in diesem Fall 20 Sek.)
```
private Handler handler = new Handler();
private TaskCanceler taskCanceler;
...
LoadData task = new LoadData();
taskCanceler = new TaskCanceler(task);
handler.postDelayed(taskCanceler, 20*1000);
task.execute(...)
```
Ist es eine gute Idee, wenn Sie sauber bis Sie auf Abbrechen oder beenden mit
```
if(taskCanceler != null && handler != null) {
     handler.removeCallbacks(taskCanceler);
}
```
Natürlich können Sie wickeln Sie diesen in eine benutzerdefinierte Implementierung von AsyncTask. Ich habe dieses Muster viele Male und es funktioniert wie ein Charme. Eine Sache zu beachten, in seltenen Fällen kann die Prozedur würde nicht starten, ich vermute, wenn Sie es schaffen, in den falschen Kontext er wird nicht überleben, in bestimmten Fällen, so ich gezwungen, der handler sein, der UI-Thread mit handler= new Handler(Looper.getMainLooper());
- Danke.... Ich werde versuchen dies und lassen Sie wissen,...
InformationsquelleAutor patrickf
3

Müssen Sie die Zeit zu überprüfen, in einem anderen thread.

Was Sie derzeit tun ist: Ausführung der dc.collectData(query) (im hintergrund) und, sobald es bereit ist, die Sie überprüfen, wenn Sie absagen sollten. Also, wenn die Abfrage dauert nur 1 minute, nehmen Sie dann die cancel-check nach 1 minute, das ist schon zu spät.

Was Sie tun können, planen Sie einen TimerTask, der ausgeführt werden soll 30 Sekunden nach der LoadData().execute() und wenn der timer-Task ausgeführt wird, können Sie Abbrechen, die AsyncTask (falls es noch läuft)
- danke für deine Antwort.... das klingt logisch... ich werde es versuchen.... Dank
- cool! Lassen Sie mich wissen, wenn es für Sie arbeitet.
InformationsquelleAutor peshkira
2

Ich würde es übersetzen in eine async/await problem damit, die ganzen teuren Methoden wie async-Methoden.

Ersten, Ändern Datensammelpunkt ist collectData(query) zu collectDataAsync(Abfrage). (Wenn Sie nicht zu ändern Sein, es gibt Problemumgehungen Arbeit, um wickeln Sie es in eine lambda-Funktion oder etwas ähnliches).

Zweitens ändern doInBackground als asynchrone Aufgabe, so etwas wie dieses:
```
protected async Task<String> doInBackgroundAsync(String... args)
{
    DataCollector dc = new DataCollector();
    int timeout = 1000;
    var task = dc.collectDataAsync(query);
    if (await Task.WhenAny(task, Task.Delay(timeout)) == task) {
        //task completed within timeout
        data = task.Result;
    } else { 
        //timeout logic
    }
}
```
Grundsätzlich haben Sie zwei Aufgaben innerhalb von doInBackgroundAsync: collectDataAsync und eine delay-Aufgabe.
Dein code wartet, bis der schnellere. Dann wissen Sie, was man war und man kann entsprechend reagieren.

Wenn Sie auch zu stornieren collectDataAsync Aufgabe, dann will man verwendet ein cancellationToken.
Ich verwende dies, um Ihr problem zu lösen https://stackoverflow.com/a/11191070/3307066.

Beachten Sie, dass jetzt doInBackgroundAsync ist eine asynchrone, so ändert es ein wenig die Art und Weise der Verwendung.

Hoffe, es hilft.
- Wenn Sie denken, diese Frage ist ein Duplikat sollten Sie die fahne als eine doppelte, statt der Entsendung einen link zu einer anderen Frage.
- Ich veränderte meine Antwort. Ich glaube nicht, dass ein Duplikat ist, hoffe es ist jetzt klar.
InformationsquelleAutor jbarrameda

versuchen Sie dies :

public class MyTask extends AsyncTask<Void, Void, Void> {

    private volatile boolean running = true;
    private final ProgressDialog progressDialog;

    public MyTask(Context ctx) {
        progressDialog = gimmeOne(ctx);

        progressDialog.setCancelable(true);
        progressDialog.setOnCancelListener(new OnCancelListener() {
            @Override
            public void onCancel(DialogInterface dialog) {
                //actually could set running = false; right here, but I'll
                //stick to contract.
                cancel(true);
            }
        });

    }

    @Override
    protected void onPreExecute() {
        progressDialog.show();
    }

    @Override
    protected void onCancelled() {
        running = false;
    }

    @Override
    protected Void doInBackground(Void... params) {

        while (running) {
            //does the hard work
        }
        return null;
    }

    //...

}

Mit freundlicher Genehmigung und für mehr details, Lesen Sie diese Antwort.

das ist richtig, aber es wird damit der Benutzer immer den Auftrag zu stornieren und wird nicht automatisch Abbrechen nach 30 Sekunden
Sie können eine timer-innen tun, in den hintergrund ,stellen Sie einige Zeit, sagen wir 30 Sekunden, und nach, dass post cancel() ..es wird halt deine asynctask an jedem Punkt
Danke für den Hinweis, aber ich möchte nicht zulassen, Benutzer, um den Vorgang abzubrechen. Und cancel(true) scheint nicht zu funktionieren für mich. Wie kann ich get(long timeout, TimeUnit unit); da ist, klingt mehr machbar.

InformationsquelleAutor Shruti

0

Kurze Antwort ist: Sie KÖNNEN NICHT kündigen ein AsyncTask einmal seine Schritte. Was Sie tun können, ist legen Sie eine Schleife in doInBackGround() Prüfung für isCancelled() und wenn es auf true festgelegt ist, irgendwann in der Zukunft - einen Wert zurückgeben von der Funktion (die wiederum rufen onPostExecute() wenn Sie es definiert);

Beachten Sie, dass, nur weil Sie nicht aufhören können, einen AsyncTask bedeutet nicht, dass das OS wird nicht Abbrechen, wenn es nicht genügend Speicher. Sie sollten dies im Hinterkopf, wenn Sie sind dabei wesentliche Aufgaben in der AsyncTask (diejenigen, die Sie wollen ausgeführt, 100%). Wenn dem so ist, ist es besser, verwenden Sie ein Service - eine Komponente, die automatisch gekillt und neu gestartet vom Betriebssystem benötigen.
- Eigentlich bin ich dem sammeln von Daten aus externen sensoren, die über die socket-verbindungen manchmal wegen der Verbindung problem oder, wenn der sensor offline ist, kann dieser Vorgang eine lange, das ist, warum ich wollen, unterbrechen Sie die Aufgabe. Sie sagen, es kann nicht storniert werden, dann warum haben wir cancel(boolean state); get(long timeout, TimeUnit unit); Methoden verfügbar?
InformationsquelleAutor Dzhuneyt

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.