Mehrere AsyncTasks gleichzeitig ausführen - nicht möglich?

Ich versuche, zwei AsyncTasks gleichzeitig auszuführen. (Plattform ist Android 1.5, HTC Hero.) Es wird jedoch nur die erste ausgeführt. Hier ist ein einfacher Ausschnitt, um mein Problem zu beschreiben:

public class AndroidJunk extends Activity {
 class PrinterTask extends AsyncTask<String, Void, Void> {
     protected Void doInBackground(String ... x) {
      while (true) {
       System.out.println(x[0]);
       try {
        Thread.sleep(1000);
       } catch (InterruptedException ie) {
        ie.printStackTrace();
       }
      }
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        new PrinterTask().execute("bar bar bar");
        new PrinterTask().execute("foo foo foo");

        System.out.println("onCreate() is done.");
    }
}

Die Ausgabe, die ich erwarte, ist:

onCreate() is done.
bar bar bar
foo foo foo
bar bar bar
foo foo foo

Und so weiter. Was ich jedoch bekomme, ist:

onCreate() is done.
bar bar bar
bar bar bar
bar bar bar

Die zweite AsyncTask wird nie ausgeführt. Wenn ich die Reihenfolge der Anweisungen execute () ändere, wird nur die Aufgabe foo ausgegeben.

Vermisse ich hier etwas Offensichtliches und / oder mache ich etwas Dummes? Ist es nicht möglich, zwei AsyncTasks gleichzeitig auszuführen?

Bearbeiten: Ich habe festgestellt, dass auf dem betreffenden Telefon Android 1.5 ausgeführt wird. Ich habe die Problembeschreibung aktualisiert. entsprechend. Ich habe dieses Problem nicht mit einem HTC Hero unter Android 2.1. Hmmm ...

AsyncTask verwendet ein Thread-Pool-Muster zum Ausführen des Materials von doInBackground (). Das Problem ist zunächst (in frühen Android-Betriebssystemversionen), dass die Poolgröße nur 1 betrug, was bedeutet, dass für eine Reihe von AsyncTasks keine parallelen Berechnungen durchgeführt wurden. Aber später haben sie das behoben und jetzt ist die Größe 5, so dass höchstens 5 AsyncTasks gleichzeitig ausgeführt werden können. Leider kann ich mich nicht erinnern, in welcher Version sie das genau geändert haben.

AKTUALISIEREN:

Hier ist, was die aktuelle (2012-01-27) API dazu sagt:

Bei der ersten Einführung wurden AsyncTasks seriell auf einem einzelnen Hintergrundthread ausgeführt. Beginnend mit DONUT wurde dies in einen Thread-Pool geändert, sodass mehrere Aufgaben gleichzeitig ausgeführt werden können. Nach HONEYCOMB ist geplant, dies wieder in einen einzelnen Thread zu ändern, um häufige Anwendungsfehler zu vermeiden, die durch parallele Ausführung verursacht werden. Wenn Sie wirklich eine parallele Ausführung wünschen, können Sie die Version executeOnExecutor (Executor, Params ...) dieser Methode mit THREAD_POOL_EXECUTOR verwenden. Im Kommentar finden Sie jedoch Warnungen zu seiner Verwendung.

DONUT ist Android 1.6, HONEYCOMB ist Android 3.0.

UPDATE: 2

Siehe den Kommentar von kabukovon Mar 7 2012 at 1:27.

Es stellt sich heraus, dass für APIs, bei denen "ein Pool von Threads verwendet wird, bei denen mehrere Aufgaben parallel ausgeführt werden können" (beginnend mit 1.6 und endend mit 3.0), die Anzahl der gleichzeitig ausgeführten AsyncTasks davon abhängt, wie viele Aufgaben bereits zur Ausführung übergeben wurden habe ihre doInBackground()noch nicht beendet .

Dies wird von mir am 2.2 getestet / bestätigt. Angenommen, Sie haben eine benutzerdefinierte AsyncTask, die nur eine Sekunde lang schläft doInBackground(). AsyncTasks verwenden intern eine Warteschlange mit fester Größe zum Speichern verzögerter Aufgaben. Die Warteschlangengröße beträgt standardmäßig 10. Wenn Sie 15 Ihrer benutzerdefinierten Aufgaben hintereinander starten, geben die ersten 5 ihre ein doInBackground(), während der Rest in einer Warteschlange auf einen freien Arbeitsthread wartet. Sobald eine der ersten 5 beendet ist und somit ein Arbeitsthread freigegeben wird, beginnt die Ausführung einer Aufgabe aus der Warteschlange. In diesem Fall werden also höchstens 5 Aufgaben gleichzeitig ausgeführt. Wenn Sie jedoch 16 Ihre benutzerdefinierten Aufgaben hintereinander starten, werden zuerst 5 eingegeben doInBackground(), die restlichen 10 werden in die Warteschlange gestellt. Für den 16. wird jedoch ein neuer Arbeitsthread erstellt, sodass die Ausführung sofort gestartet wird. In diesem Fall werden also höchstens 6 Aufgaben gleichzeitig ausgeführt.

Es gibt eine Begrenzung, wie viele Aufgaben gleichzeitig ausgeführt werden können. Da AsyncTaskein Thread-Pool-Executor mit einer begrenzten maximalen Anzahl von Worker-Threads (128) verwendet wird und die Warteschlange für verzögerte Aufgaben die feste Größe 10 hat, stürzt die App ab, wenn Sie versuchen, mehr als 138 Ihrer benutzerdefinierten Aufgaben auszuführen java.util.concurrent.RejectedExecutionException.

Ab 3.0 ermöglicht die API die Verwendung Ihres benutzerdefinierten Thread-Pool-Executors über die AsyncTask.executeOnExecutor(Executor exec, Params... params)Methode. Auf diese Weise können Sie beispielsweise die Größe der Warteschlange für verzögerte Aufgaben konfigurieren, wenn Sie nicht die Standardeinstellung 10 benötigen.

Wie @Knossos erwähnt, gibt es eine Option AsyncTaskCompat.executeParallel(task, params);aus der Support v.4-Bibliothek, um Aufgaben parallel auszuführen, ohne sich um die API-Ebene zu kümmern . Diese Methode wurde in API-Level 26.0.0 nicht mehr unterstützt.

UPDATE: 3

Hier ist eine einfache Test-App zum Spielen mit einer Reihe von Aufgaben, serielle oder parallele Ausführung: https://github.com/vitkhudenko/test_asynctask

UPDATE: 4 (danke @penkzhou für den Hinweis)

Ab Android 4.4 AsyncTaskverhält es sich anders als im Abschnitt UPDATE: 2 beschrieben . Es gibt eine Korrektur , um zu verhindern, AsyncTaskdass zu viele Threads erstellt werden.

Vor Android 4.4 (API 19) gab AsyncTaskes folgende Felder:

private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(10);

In Android 4.4 (API 19) werden die obigen Felder folgendermaßen geändert:

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);

Diese Änderung erhöht die Größe der Warteschlange auf 128 Elemente und reduziert die maximale Anzahl von Threads auf die Anzahl von CPU-Kernen * 2 + 1. Apps können weiterhin dieselbe Anzahl von Aufgaben senden.

Dies ermöglicht die parallele Ausführung auf allen Android-Versionen mit API 4+ (Android 1.6+):

@TargetApi(Build.VERSION_CODES.HONEYCOMB) // API 11
void startMyTask(AsyncTask asyncTask) {
    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
    else
        asyncTask.execute(params);
}

Dies ist eine Zusammenfassung von Arhimeds ausgezeichneter Antwort.

Stellen Sie sicher, dass Sie API Level 11 oder höher als Projekterstellungsziel verwenden. In Eclipse also Project > Properties > Android > Project Build Target. Dadurch wird die Abwärtskompatibilität mit niedrigeren API-Ebenen nicht beeinträchtigt. Keine Sorge, Sie erhalten Lint-Fehler, wenn Sie versehentlich Funktionen verwenden, die später als eingeführt wurden minSdkVersion. Wenn Sie wirklich als Funktionen nutzen eingeführt später möchten minSdkVersion, können Sie diese Fehler mit Anmerkungen zu unterdrücken, aber in diesem Fall müssen Sie kümmern sich um die Kompatibilität nehmen selbst . Genau das ist im obigen Code-Snippet passiert.

@ Sulai-Vorschlag allgemeiner gestalten:

@TargetApi(Build.VERSION_CODES.HONEYCOMB) // API 11
public static <T> void executeAsyncTask(AsyncTask<T, ?, ?> asyncTask, T... params) {
    if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
    else
        asyncTask.execute(params);
}   

Nur um das neueste Update (UPDATE 4) in @Arhimeds makellose Antwort in die sehr gute Zusammenfassung von @sulai aufzunehmen:

void doTheTask(AsyncTask task) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { // Android 4.4 (API 19) and above
        // Parallel AsyncTasks are possible, with the thread-pool size dependent on device
        // hardware
        task.execute(params);
    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { // Android 3.0 to
        // Android 4.3
        // Parallel AsyncTasks are not possible unless using executeOnExecutor
        task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, params);
    } else { // Below Android 3.0
        // Parallel AsyncTasks are possible, with fixed thread-pool size
        task.execute(params);
    }
}

Das Beispiel für Android-Entwickler zum effizienten Laden von Bitmaps verwendet eine benutzerdefinierte Asynctask (aus Jellybean kopiert), sodass Sie den executeOnExecutor in APIs unter <11 verwenden können

http://developer.android.com/training/displaying-bitmaps/index.html

Laden Sie den Code herunter und gehen Sie zum Util-Paket.

Es ist möglich. Meine Android-Geräteversion ist 4.0.4 und android.os.Build.VERSION.SDK_INT ist 15

Ich habe 3 Spinner

Spinner c_fruit=(Spinner) findViewById(R.id.fruits);
Spinner c_vegetable=(Spinner) findViewById(R.id.vegetables);
Spinner c_beverage=(Spinner) findViewById(R.id.beverages);

Und ich habe auch eine Async-Tack-Klasse.

Hier ist mein Spinner-Ladecode

RequestSend reqs_fruit = new RequestSend(this);
reqs_fruit.where="Get_fruit_List";
reqs_fruit.title="Loading fruit";
reqs_fruit.execute();

RequestSend reqs_vegetable = new RequestSend(this);
reqs_vegetable.where="Get_vegetable_List";
reqs_vegetable.title="Loading vegetable";
reqs_vegetable.execute();

RequestSend reqs_beverage = new RequestSend(this);
reqs_beverage.where="Get_beverage_List";
reqs_beverage.title="Loading beverage";
reqs_beverage.execute();

Das funktioniert perfekt. Einer nach dem anderen luden meine Spinner. Ich habe den Benutzer executeOnExecutor nicht verwendet.

Hier ist meine Async-Task-Klasse

public class RequestSend  extends AsyncTask<String, String, String > {

    private ProgressDialog dialog = null;
    public Spinner spin;
    public String where;
    public String title;
    Context con;
    Activity activity;      
    String[] items;

    public RequestSend(Context activityContext) {
        con = activityContext;
        dialog = new ProgressDialog(activityContext);
        this.activity = activityContext;
    }

    @Override
    protected void onPostExecute(String result) {
        try {
            ArrayAdapter<String> adapter = new ArrayAdapter<String> (activity, android.R.layout.simple_spinner_item, items);       
            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
            spin.setAdapter(adapter);
        } catch (NullPointerException e) {
            Toast.makeText(activity, "Can not load list. Check your connection", Toast.LENGTH_LONG).show();
            e.printStackTrace();
        } catch (Exception e)  {
            Toast.makeText(activity, "Can not load list. Check your connection", Toast.LENGTH_LONG).show();
            e.printStackTrace();
        }
        super.onPostExecute(result);

        if (dialog != null)
            dialog.dismiss();   
    }

    protected void onPreExecute() {
        super.onPreExecute();
        dialog.setTitle(title);
        dialog.setMessage("Wait...");
        dialog.setCancelable(false); 
        dialog.show();
    }

    @Override
    protected String doInBackground(String... Strings) {
        try {
            Send_Request();
            } catch (NullPointerException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        return null;
    }

    public void Send_Request() throws JSONException {

        try {
            String DataSendingTo = "http://www.example.com/AppRequest/" + where;
            //HttpClient
            HttpClient httpClient = new DefaultHttpClient();
            //Post header
            HttpPost httpPost = new HttpPost(DataSendingTo);
            //Adding data
            List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);

            nameValuePairs.add(new BasicNameValuePair("authorized","001"));

            httpPost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
            // execute HTTP post request
            HttpResponse response = httpClient.execute(httpPost);

            BufferedReader reader;
            try {
                reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));
                StringBuilder builder = new StringBuilder();
                String line = null;
                while ((line = reader.readLine()) != null) {
                    builder.append(line) ;
                }

                JSONTokener tokener = new JSONTokener(builder.toString());
                JSONArray finalResult = new JSONArray(tokener);
                items = new String[finalResult.length()]; 
                // looping through All details and store in public String array
                for(int i = 0; i < finalResult.length(); i++) {
                    JSONObject c = finalResult.getJSONObject(i);
                    items[i]=c.getString("data_name");
                }

            } catch (ClientProtocolException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Wenn Sie Aufgaben parallel ausführen möchten, müssen Sie die Methode executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "your task name")nach der Android-Version 3.0 aufrufen . Diese Methode ist jedoch vor Android 3.0 und nach 1.6 nicht vorhanden, da sie von selbst parallel ausgeführt wird. Ich empfehle daher, dass Sie Ihre eigene AsyncTask-Klasse in Ihrem Projekt anpassen, um Ausnahmen in anderen Android-Versionen zu vermeiden.