AsyncTask Klasse

Definition

[Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)]
[Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })]
public abstract class AsyncTask : Java.Lang.Object

[<Android.Runtime.Register("android/os/AsyncTask", DoNotGenerateAcw=true)>]
[<Java.Interop.JavaTypeParameters(new System.String[] { "Params", "Progress", "Result" })>]
type AsyncTask = class
    inherit Object

Vererbung

Object

JavaObject

Object

AsyncTask

Abgeleitet

Android.OS.AsyncTask<TParams,TProgress,TResult>

Attribute

RegisterAttribute JavaTypeParametersAttribute

Hinweise

AsyncTask sollte die ordnungsgemäße und einfache Verwendung des UI-Threads ermöglichen. Der am häufigsten verwendete Anwendungsfall war jedoch für die Integration in die Benutzeroberfläche, was zu Kontextlecks, verpassten Rückrufen oder Abstürzen bei Konfigurationsänderungen führen würde. Es hat auch inkonsistentes Verhalten in verschiedenen Versionen der Plattform, verschluckt Ausnahmen von doInBackgroundund bietet nicht viel Nutzen über die direkte Verwendung Executorvon s.

AsyncTask ist als Hilfsklasse Thread konzipiert und Handler stellt kein generisches Threadingframework dar. AsyncTasks sollten idealerweise für kurze Vorgänge (höchstens einige Sekunden) verwendet werden.) Wenn Sie Threads über einen längeren Zeitraum ausführen müssen, wird dringend empfohlen, die verschiedenen APIs zu verwenden, die java.util.concurrent vom Paket bereitgestellt werden, z Executor. B. und ThreadPoolExecutorFutureTask.

Eine asynchrone Aufgabe wird durch eine Berechnung definiert, die in einem Hintergrundthread ausgeführt wird und dessen Ergebnis im UI-Thread veröffentlicht wird. Eine asynchrone Aufgabe wird durch 3 generische Typen definiert, die aufgerufen Paramswerden, und Progress4 Schritte, die als Result, onPreExecuteund doInBackgroundonProgressUpdate . onPostExecute

<div class="special reference"><h3>Developer Guides</h3>

Weitere Informationen zur Verwendung von Aufgaben und Threads finden Sie im Entwicklerhandbuch für Prozesse und Threads .

</Div>

<h2>Verwendung</h2>

AsyncTask muss unterklassig sein, damit sie verwendet werden kann. Die Unterklasse überschreibt mindestens eine Methode (#doInBackground), und meistens wird eine zweite (#onPostExecute.) außer Kraft setzen.

Hier ist ein Beispiel für Unterklassen:

private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {
                protected Long doInBackground(URL... urls) {
                    int count = urls.length;
                    long totalSize = 0;
                    for (int i = 0; i < count; i++) {
                        totalSize += Downloader.downloadFile(urls[i]);
                        publishProgress((int) ((i / (float) count) * 100));
                        // Escape early if cancel() is called
                        if (isCancelled()) break;
                    }
                    return totalSize;
                }

                protected void onProgressUpdate(Integer... progress) {
                    setProgressPercent(progress[0]);
                }

                protected void onPostExecute(Long result) {
                    showDialog("Downloaded " + result + " bytes");
                }
            }

Nach der Erstellung wird eine Aufgabe sehr einfach ausgeführt:

new DownloadFilesTask().execute(url1, url2, url3);

<generische Typen>/h2 von h2<AsyncTask>

Die drei Typen, die von einer asynchronen Aufgabe verwendet werden, sind die folgenden:

<ol><li>Params, der Typ der Parameter, die bei der Ausführung an die Aufgabe gesendet werden.</li li><>Progress, der Typ der Statuseinheiten, die während der Hintergrundberechnung veröffentlicht wurden.</li li><>Result, der Typ des Ergebnisses der Hintergrundberechnung.</li></ol>

Nicht alle Typen werden immer von einer asynchronen Aufgabe verwendet. Um einen Typ als nicht verwendet zu markieren, verwenden Sie einfach den Typ Void:

private class MyTask extends AsyncTask<Void, Void, Void> { ... }

<h2>Die 4 Schritte</h2>

Wenn eine asynchrone Aufgabe ausgeführt wird, durchläuft die Aufgabe vier Schritte:

<ol><li>#onPreExecute(), aufgerufen im UI-Thread, bevor die Aufgabe ausgeführt wird. Dieser Schritt wird normalerweise verwendet, um die Aufgabe einzurichten, z. B. durch Anzeigen einer Statusanzeige auf der Benutzeroberfläche.</li li><>#doInBackground, wird unmittelbar nach #onPreExecute() Abschluss der Ausführung im Hintergrundthread aufgerufen. Dieser Schritt wird verwendet, um die Hintergrundberechnung durchzuführen, die eine lange Zeit in Anspruch nehmen kann. Die Parameter der asynchronen Aufgabe werden an diesen Schritt übergeben. Das Ergebnis der Berechnung muss von diesem Schritt zurückgegeben werden und wird an den letzten Schritt übergeben. Dieser Schritt kann auch zum Veröffentlichen einer oder mehrerer Fortschrittseinheiten verwendet werden #publishProgress . Diese Werte werden im UI-Thread im #onProgressUpdate Schritt veröffentlicht.</li li><>#onProgressUpdate, aufgerufen im UI-Thread nach einem Aufruf von .#publishProgress Der Zeitpunkt der Ausführung ist nicht definiert. Diese Methode wird verwendet, um jede Form des Fortschritts auf der Benutzeroberfläche anzuzeigen, während die Hintergrundberechnung noch ausgeführt wird. Beispielsweise kann es verwendet werden, um eine Statusleiste zu animieren oder Protokolle in einem Textfeld anzuzeigen.</li li><>#onPostExecute, aufgerufen im UI-Thread, nachdem die Hintergrundberechnung abgeschlossen wurde. Das Ergebnis der Hintergrundberechnung wird als Parameter an diesen Schritt übergeben.</li></ol>

<h2>Abbrechen eines Vorgangs</h2>

Eine Aufgabe kann jederzeit durch Aufrufen #cancel(boolean)abgebrochen werden. Das Aufrufen dieser Methode führt dazu #isCancelled() , dass nachfolgende Aufrufe "true" zurückgeben. Nach dem Aufrufen dieser Methode #onCancelled(Object)wird anstelle von #onPostExecute(Object) Rückgaben #doInBackground(Object[]) die Methode aufgerufen. Um sicherzustellen, dass eine Aufgabe so schnell wie möglich abgebrochen wird, sollten Sie den Rückgabewert #isCancelled() in regelmäßigen Abständen von #doInBackground(Object[]), falls möglich (z. B. innerhalb einer Schleife), überprüfen.)

<h2>Threadingregeln</h2>

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

<ul><li>Die AsyncTask-Klasse muss im UI-Thread geladen werden. Dies erfolgt automatisch ab android.os.Build.VERSION_CODES#JELLY_BEAN.</li Li><>Die Aufgabeninstanz muss im UI-Thread erstellt werden.</li li><>#execute muss im UI-Thread aufgerufen werden.</li li><>Nicht anrufen #onPreExecute(), , #onPostExecute, #doInBackground#onProgressUpdate manuell.</li Li><>Die Aufgabe kann nur einmal ausgeführt werden (eine Ausnahme wird ausgelöst, wenn eine zweite Ausführung versucht wird.)</li></ul>

<h2>Speicher observability</h2>

AsyncTask garantiert, dass alle Rückrufaufrufe synchronisiert werden, um Folgendes ohne explizite Synchronisierungen sicherzustellen.

<ul><li>Die Speichereffekte und #onPreExecutealles andere, was vor dem Aufruf #executeausgeführt wird, einschließlich der Konstruktion des AsyncTask-Objekts, sind sichtbar.#doInBackground <li>Die Speichereffekte von #doInBackground sind sichtbar für #onPostExecute. <li>Alle Speichereffekte des #doInBackground vorherigen Aufrufs #publishProgress sind für den entsprechenden #onProgressUpdate Aufruf sichtbar. (Es wird jedoch #doInBackground weiterhin ausgeführt, und es muss darauf geachtet werden, dass spätere Aktualisierungen #doInBackground keinen Konflikt mit einem laufenden #onProgressUpdate Anruf haben.) <li>Alle Speichereffekte, die einem Aufruf #cancel vorausgehen, sind nach einem Aufruf sichtbar, der #isCancelled "true" als Ergebnis oder während und nach einem resultierenden Aufruf zurückgibt #onCancelled. </ul>

<h2>Reihenfolge der Ausführung</h2>

Bei der ersten Einführung wurden AsyncTasks serial in einem einzelnen Hintergrundthread ausgeführt. Beginnend mit android.os.Build.VERSION_CODES#DONUT, wurde dies in einen Pool von Threads geändert, sodass mehrere Aufgaben parallel ausgeführt werden können. Beginnend mit android.os.Build.VERSION_CODES#HONEYCOMB, werden Aufgaben in einem einzigen Thread ausgeführt, um häufige Anwendungsfehler zu vermeiden, die durch parallele Ausführung verursacht werden.

Wenn Sie wirklich parallele Ausführung wünschen, können Sie mit #executeOnExecutor(java.util.concurrent.Executor, Object[]).#THREAD_POOL_EXECUTOR

Dieses Element ist veraltet. Verwenden Sie stattdessen die Standard java.util.concurrent - oder Kotlin-Parallelitätshilfsprogramme .

Java Dokumentation für android.os.AsyncTask.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.