AsyncTask Classe

Definição

[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

Herança

Object

JavaObject

Object

AsyncTask

Derivado

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

Atributos

RegisterAttribute JavaTypeParametersAttribute

Comentários

O AsyncTask destinava-se a habilitar o uso adequado e fácil do thread de interface do usuário. No entanto, o caso de uso mais comum foi a integração à interface do usuário e isso causaria vazamentos de contexto, retornos de chamada perdidos ou falhas nas alterações de configuração. Ele também tem um comportamento inconsistente em diferentes versões da plataforma, engole exceções doInBackgrounde não fornece muito utilitário sobre o uso Executorde s diretamente.

AsyncTask foi projetado para ser uma classe auxiliar e ThreadHandler não constitui uma estrutura de threading genérica. AsyncTasks devem ser usados idealmente para operações curtas (no máximo alguns segundos).) Se você precisar manter os threads em execução por longos períodos de tempo, é altamente recomendável usar as várias APIs fornecidas pelo java.util.concurrent pacote, como Executore ThreadPoolExecutorFutureTask.

Uma tarefa assíncrona é definida por uma computação que é executada em um thread em segundo plano e cujo resultado é publicado no thread da interface do usuário. Uma tarefa assíncrona é definida por 3 tipos genéricos, chamados Paramse ProgressResult, e 4 etapas, chamadas onPreExecute, doInBackgroundonProgressUpdate e onPostExecute.

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

Para obter mais informações sobre como usar tarefas e threads, leia o guia do desenvolvedor processos e threads .

</div>

<h2>Uso</h2>

AsyncTask deve ser subclasse para ser usado. A subclasse substituirá pelo menos um método (#doInBackground) e, na maioria das vezes, substituirá um segundo (#onPostExecute.)

Aqui está um exemplo de subclasse:

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

Depois de criada, uma tarefa é executada de forma muito simples:

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

<Tipos> genéricos/h2<de AsyncTask/h2>

Os três tipos usados por uma tarefa assíncrona são os seguintes:

<ol><li>Params, o tipo dos parâmetros enviados para a tarefa após a execução.</li><li>Progress, o tipo das unidades de progresso publicadas durante a computação em segundo plano.</li><li>Result, o tipo do resultado da computação em segundo plano.</li></ol>

Nem todos os tipos são sempre usados por uma tarefa assíncrona. Para marcar um tipo como não utilizado, basta usar o tipo Void:

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

<h2>As 4 etapas</h2>

Quando uma tarefa assíncrona é executada, a tarefa passa por 4 etapas:

<ol><li>#onPreExecute(), invocado no thread da interface do usuário antes que a tarefa seja executada. Essa etapa normalmente é usada para configurar a tarefa, por exemplo, mostrando uma barra de progresso na interface do usuário.</li><li>#doInBackground, invocado no thread em segundo plano imediatamente após #onPreExecute() a conclusão da execução. Esta etapa é usada para executar a computação em segundo plano que pode levar muito tempo. Os parâmetros da tarefa assíncrona são passados para esta etapa. O resultado da computação deve ser retornado por esta etapa e será passado de volta para a última etapa. Essa etapa também pode ser usada #publishProgress para publicar uma ou mais unidades de progresso. Esses valores são publicados no thread da interface do usuário, na #onProgressUpdate etapa.</li><li>#onProgressUpdate, invocado no thread da interface do usuário após uma chamada para #publishProgress. O tempo da execução é indefinido. Esse método é usado para exibir qualquer forma de progresso na interface do usuário enquanto a computação em segundo plano ainda está em execução. Por exemplo, ele pode ser usado para animar uma barra de progresso ou mostrar logs em um campo de texto.</li><li>#onPostExecute, invocado no thread da interface do usuário após a conclusão da computação em segundo plano. O resultado da computação em segundo plano é passado para essa etapa como um parâmetro.</li></ol>

<h2>Cancelando uma tarefa</h2>

Uma tarefa pode ser cancelada a qualquer momento invocando #cancel(boolean). Invocar esse método fará com que as chamadas subsequentes #isCancelled() retornem true. Depois de invocar esse método, #onCancelled(Object)em vez de #onPostExecute(Object) ser invocado após #doInBackground(Object[]) o retorno. Para garantir que uma tarefa seja cancelada o mais rápido possível, você sempre deve verificar o valor retornado de #isCancelled() periodicamente de #doInBackground(Object[]), se possível (dentro de um loop, por exemplo).

<h2>Regras< de threading/h2>

Há algumas regras de threading que devem ser seguidas para que essa classe funcione corretamente:

<ul><li>A classe AsyncTask deve ser carregada no thread da interface do usuário. Isso é feito automaticamente a partir de android.os.Build.VERSION_CODES#JELLY_BEAN.</li><li>A instância da tarefa deve ser criada no thread da interface do usuário.</li><li>#execute deve ser invocado no thread da interface do usuário.</li li><>Não chamar#onPreExecute(), #onPostExecute, , #doInBackground#onProgressUpdate manualmente.</li><li>A tarefa pode ser executada apenas uma vez (uma exceção será gerada se uma segunda execução for tentada.)</li></ul>

<observabilidade de> memória h2</h2>

AsyncTask garante que todas as chamadas de retorno de chamada sejam sincronizadas para garantir o seguinte sem sincronizações explícitas.

<ul><li>Os efeitos de memória de #onPreExecute, e qualquer outra coisa executada antes da chamada para #execute, incluindo a construção do objeto AsyncTask, são visíveis para #doInBackground. <li>Os efeitos de memória de #doInBackground são visíveis para #onPostExecute. <li>Quaisquer efeitos de memória da #doInBackground chamada anterior a #publishProgress serem visíveis para a chamada correspondente #onProgressUpdate . (Mas #doInBackground continua em execução e é necessário tomar cuidado para que as atualizações posteriores #doInBackground não interfiram em uma chamada em andamento #onProgressUpdate .) <li>Quaisquer efeitos de memória anteriores a uma chamada ficam #cancel visíveis após uma chamada para #isCancelled que retorna true como resultado, ou durante e após uma chamada resultante para #onCancelled. </ul>

<h2>Ordem de execução</h2>

Quando introduzidos pela primeira vez, as AsyncTasks foram executados serialmente em um único thread em segundo plano. android.os.Build.VERSION_CODES#DONUTA partir de então, isso foi alterado para um pool de threads, permitindo que várias tarefas operassem em paralelo. A partir de android.os.Build.VERSION_CODES#HONEYCOMBentão, as tarefas são executadas em um único thread para evitar erros comuns de aplicativo causados pela execução paralela.

Se você realmente quiser a execução paralela, poderá invocar #executeOnExecutor(java.util.concurrent.Executor, Object[]) com #THREAD_POOL_EXECUTOR.

Este membro foi preterido. Em vez disso, use os java.util.concurrent ou padrão.

Java documentação para android.os.AsyncTask.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.