AsyncTask Classe

Definizione

[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

Ereditarietà

Object

JavaObject

Object

AsyncTask

Derivato

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

Attributi

RegisterAttribute JavaTypeParametersAttribute

Commenti

AsyncTask è stato progettato per abilitare l'uso corretto e semplice del thread dell'interfaccia utente. Tuttavia, il caso d'uso più comune riguarda l'integrazione nell'interfaccia utente e ciò causerebbe perdite di contesto, callback mancanti o arresti anomali nelle modifiche alla configurazione. Ha anche un comportamento incoerente su versioni diverse della piattaforma, ingoia le eccezioni da doInBackgrounde non fornisce molta utilità rispetto all'uso Executordiretto di s.

AsyncTask è progettato per essere una classe helper intorno Thread a e Handler non costituisce un framework di threading generico. AsyncTasks dovrebbe essere usato idealmente per operazioni brevi (alcuni secondi al massimo). Se è necessario mantenere i thread in esecuzione per lunghi periodi di tempo, è consigliabile usare le varie API fornite dal java.util.concurrent pacchetto, ad Executoresempio , ThreadPoolExecutor e FutureTask.

Un'attività asincrona viene definita da un calcolo eseguito su un thread in background e il cui risultato viene pubblicato nel thread dell'interfaccia utente. Un'attività asincrona è definita da 3 tipi generici, denominati Params, Progress e Resulte 4 passaggi, denominati onPreExecute, doInBackgroundonProgressUpdate e onPostExecute.

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

Per altre informazioni sull'uso di attività e thread, vedere la guida per sviluppatori processi e thread .

</div>

<h2>Usage</h2>

Per poter essere usato, è necessario che AsyncTask sia sottoclassato. La sottoclasse eseguirà l'override di almeno un metodo (#doInBackground) e spesso eseguirà l'override di un secondo (#onPostExecute.)

Di seguito è riportato un esempio di sottoclasse:

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

Una volta creata, un'attività viene eseguita molto semplicemente:

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

<tipi generici> h2<AsyncTask/h2>

I tre tipi usati da un'attività asincrona sono i seguenti:

<ol><li>Params, il tipo dei parametri inviati all'attività al momento dell'esecuzione.</li><li>Progress, il tipo delle unità di stato pubblicate durante il calcolo in background.</li><li>Result, il tipo del risultato del calcolo in background.</li></ol>

Non tutti i tipi vengono sempre usati da un'attività asincrona. Per contrassegnare un tipo come inutilizzato, è sufficiente usare il tipo Void:

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

<h2>I 4 passaggi</h2>

Quando viene eseguita un'attività asincrona, l'attività esegue 4 passaggi:

<ol><li>#onPreExecute(), richiamato sul thread dell'interfaccia utente prima dell'esecuzione dell'attività. Questo passaggio viene in genere usato per configurare l'attività, ad esempio mostrando una barra di stato nell'interfaccia utente.</li><li>#doInBackground, richiamato sul thread in background immediatamente dopo #onPreExecute() il completamento dell'esecuzione. Questo passaggio viene usato per eseguire il calcolo in background che può richiedere molto tempo. I parametri dell'attività asincrona vengono passati a questo passaggio. Il risultato del calcolo deve essere restituito da questo passaggio e verrà passato all'ultimo passaggio. Questo passaggio può essere usato #publishProgress anche per pubblicare una o più unità di avanzamento. Questi valori vengono pubblicati nel thread dell'interfaccia utente nel #onProgressUpdate passaggio .</li><li>#onProgressUpdate, richiamato sul thread dell'interfaccia utente dopo una chiamata a #publishProgress. La tempistica dell'esecuzione non è definita. Questo metodo viene usato per visualizzare qualsiasi forma di avanzamento nell'interfaccia utente mentre il calcolo in background è ancora in esecuzione. Ad esempio, può essere usato per animare un indicatore di stato o visualizzare i log in un campo di testo.</li><li>#onPostExecute, richiamato sul thread dell'interfaccia utente al termine del calcolo in background. Il risultato del calcolo in background viene passato a questo passaggio come parametro.</li></ol>

<h2>Annullamento di un'attività</h2>

Un'attività può essere annullata in qualsiasi momento richiamando #cancel(boolean). Il richiamo di questo metodo causerà la restituzione di true delle chiamate #isCancelled() successive. Dopo aver richiamato questo metodo, #onCancelled(Object), invece di #onPostExecute(Object) verrà richiamato dopo #doInBackground(Object[]) la restituzione. Per assicurarsi che un'attività venga annullata il più rapidamente possibile, è consigliabile controllare sempre il valore restituito di periodicamente da #isCancelled(), se possibile (all'interno di #doInBackground(Object[]) un ciclo per esempio).

<h2>Regole< di threading/h2>

Per il corretto funzionamento di questa classe, è necessario seguire alcune regole di threading:

<ul><li>La classe AsyncTask deve essere caricata nel thread dell'interfaccia utente. Questa operazione viene eseguita automaticamente a partire da android.os.Build.VERSION_CODES#JELLY_BEAN.</li><li>L'istanza dell'attività deve essere creata nel thread dell'interfaccia utente.</li><li>#execute deve essere richiamato nel thread dell'interfaccia utente.</li><li>Non chiamare #onPreExecute(), #onPostExecute, #doInBackground, #onProgressUpdate manualmente.</li><Li>L'attività può essere eseguita una sola volta (verrà generata un'eccezione se viene tentata una seconda esecuzione).</li></ul>

<h2>Osservabilità< memoria/h2>

AsyncTask garantisce che tutte le chiamate di callback siano sincronizzate per garantire quanto segue senza sincronizzazioni esplicite.

<ul><li>Gli effetti della memoria di #onPreExecutee qualsiasi altra operazione eseguita prima della chiamata a #execute, inclusa la costruzione dell'oggetto AsyncTask, sono visibili a #doInBackground. <li>Gli effetti della memoria di #doInBackground sono visibili a #onPostExecute. <li>Qualsiasi effetto di memoria di #doInBackground una chiamata a #publishProgress è visibile alla chiamata corrispondente #onProgressUpdate . (Ma #doInBackground continua a essere eseguito e occorre prestare attenzione che gli aggiornamenti successivi in #doInBackground non interferiscano con una chiamata in corso #onProgressUpdate . <li>Qualsiasi effetto di memoria precedente a una chiamata a #cancel è visibile dopo una chiamata a #isCancelled che restituisce true come risultato o durante e dopo una chiamata risultante a #onCancelled. </ul>

<h2>Ordine di esecuzione</h2>

Quando è stato introdotto per la prima volta, AsyncTasks è stato eseguito in modo seriale su un singolo thread in background. android.os.Build.VERSION_CODES#DONUTA partire da , questo è stato modificato in un pool di thread che consente l'uso in parallelo di più attività. android.os.Build.VERSION_CODES#HONEYCOMBA partire da , le attività vengono eseguite su un singolo thread per evitare errori comuni dell'applicazione causati dall'esecuzione parallela.

Se si vuole realmente eseguire in parallelo, è possibile richiamare #executeOnExecutor(java.util.concurrent.Executor, Object[]) con #THREAD_POOL_EXECUTOR.

Questo membro è deprecato. Usare invece le utilità di concorrenza standard java.util.concurrent o Kotlin .

per android.os.AsyncTask.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dalla e usati in base ai termini descritti in Creative License 2.5 Attribution License.