Vraag Android AsyncTask - Order van uitvoering


Ik heb te maken met een probleem met betrekking tot de volgorde van execntie van AsyncTasks.

Mijn vraag is :

Ervan uitgaande dat ik 2 implementaties van AsyncTask heb: MyAsyncTask1 en MyAsyncTask2

Die worden op de volgende manier genoemd:

new MyAsyncTask1 ().execute ();
new MyAsyncTask2 ().execute ();

Is het gegarandeerd dat MyAsyncTask1 is eerder uitgevoerd MyAsyncTask2 ? Eén ding is zeker: ze worden niet parallel uitgevoerd omdat de standaard executor wordt gebruikt, namelijk SERIAL_EXECUTOR. Het probleem ligt in de volgorde van uitvoering: welke zal eerst worden uitgevoerd?

Als de volgorde van uitvoering niet wordt bepaald, hoe kan ik dan een uitvoerorder voor de AsyncTasks afdwingen?

Wat ik nodig heb, is hebben MyAsyncTask1 eerder uitgevoerd MyAsyncTask2, wat niet altijd het geval is, ook al roep ik om execute MyAsyncTask1 voor MyAsyncTask2.

Wat ik eigenlijk heb is een aangepaste activiteit:

public abstract class CustomActivity extends Activity {

    @Override
    protected void onCreate ( Bundle savedInstanceState ) {
        super.onCreate ( savedInstanceState );
        new MyAsyncTask2 ().execute ();
    }
}

En nog een activiteit die erft van de aangepaste activiteit:

public class MainActivity extends CustomActivity {

    @Override
    protected void onCreate ( Bundle savedInstanceState ) {
        new MyAsyncTask1 ().execute ();
        super.onCreate ( savedInstanceState );
    }
}

Dus als ik de Hoofdactiviteit, MyAsyncTask1 moet eerder worden uitgevoerd MyAsyncTask2tenminste dat is het gedrag dat ik nodig heb.


11
2017-11-05 08:00


oorsprong


antwoorden:


De enige manier om ervoor te zorgen dat twee threads (dat is wat AsyncTasks eigenlijk is) worden uitgevoerd in de door u gewenste volgorde, is om de tweede thread te starten wanneer de eerste klaar is.

In uw geval, om de uitvoering geabstraheerd te houden en AsyncTask2 eigenlijk niet in de onPostExecute van AsyncTask1 (zoals Anup en Sanket suggereerden, wat ook prima is als je ze wilt mixen), laat AsyncTask1 bellen super.executeAsyncTask2(), waar executeAsyncTask2() is een methode in uw CustomActivity waarmee het tweede AsyncTask wordt gestart


4
2017-11-05 08:10



Om een ​​willekeurig aantal AsyncTasks te "ketenen", heb ik mijn AsyncTasks een aangepaste terugbelopdracht als parameter. Je moet het zo definiëren:

public interface AsyncCallback(){
    public void onAsyncTaskFinished();
}

Uw AsyncTask-implementatieconstructor zou een AsyncCallback als parameter moeten hebben, zoals deze:

private AsyncCallback callback;

public AsyncTaskImplementation(AsyncCallback callback){
    //Do whatever you're doing here
    this.callback = callback;
}

Natuurlijk, als ze meer parameters hebben, verwijder ze dan niet.

Dan, net voor het einde van onPostExecute, introduceer dit:

if (callback != null) callback.onAsyncTaskFinished();

Dus als u een callback doorgeeft, voert AsyncTask uw callback uit in de hoofdthread. Als u geen terugbellen wilt uitvoeren, hoeft u alleen maar door te geven null

Dus, om je AsyncTask-keten te bellen, schrijf je dit gewoon:

new AsyncTask1(new AsyncCallback(){

    public void onAsyncTaskFinished(){
         new AsyncTask2(null).execute();
    }

}).execute();

Ik hoop dat dit je helpt ;-)


3
2017-11-05 11:08



Roep uw tweede Async-taak aan het einde van de eerste Aysnc-taak (d.w.z. aan het einde van de onPostExecute() methode van uw eerste async-taak)

//first async task's onPostExecute method

onPostExecute()
{
//do your stuff and call second async task

new MyAsyncTask2 ().execute ();

}

Dit zal de uitvoering van de tweede taak na de eerste op een eenvoudige en elegante manier garanderen.


0
2017-11-05 08:05



Oproep 2e taak in onPostExecute van taak 1 als

@Override
protected void onPostExecute(String string){//String or whatever u passed
    new MyAsyncTask2 ().execute ();
}

0
2017-11-05 08:08



AsyncTask wordt op de achtergrond uitgevoerd, dus in uw geval start de eerste code task1 en start meteen task2 .. dus bel

new MyAsyncTask2 ().execute ();

dit om postexecute van Task1 in te voeren


-1
2017-11-05 08:05



Maak het u niet moeilijk en probeer uw ontwerp eenvoudig en schoon te houden. De race tussen uw beide AsyncTasks is afhankelijk van de hoeveelheid verwerking die ze in hun overrided-methoden verwerken. Logisch gezien, als u wilt dat uw AsyncTask1 vóór AsyncTask2 voltooid is, voegt u eenvoudig de code-blokken van uw tweede Async toe aan de eerste.

Of start uw tweede Async vanuit de onPostExecute van je eerste Async - maar dat lijkt persoonlijk niet nodig.


-1
2017-11-05 08:08