ThreadPoolExecutor Classe

Definição

Namespace:

Java.Util.Concurrent

Assembly:

Mono.Android.dll

Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.

[Android.Runtime.Register("java/util/concurrent/ThreadPoolExecutor", DoNotGenerateAcw=true)]
public class ThreadPoolExecutor : Java.Util.Concurrent.AbstractExecutorService

[<Android.Runtime.Register("java/util/concurrent/ThreadPoolExecutor", DoNotGenerateAcw=true)>]
type ThreadPoolExecutor = class
    inherit AbstractExecutorService

Herança

Object

Object

AbstractExecutorService

ThreadPoolExecutor

Derivado

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Atributos

RegisterAttribute

Comentários

Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.

Os pools de threads resolvem dois problemas diferentes: eles geralmente fornecem melhor desempenho ao executar um grande número de tarefas assíncronas, devido à sobrecarga de invocação por tarefa reduzida, e fornecem um meio de limitar e gerenciar os recursos, incluindo threads, consumidos ao executar uma coleção de tarefas. Cada um ThreadPoolExecutor também mantém algumas estatísticas básicas, como o número de tarefas concluídas.

Para ser útil em uma ampla gama de contextos, essa classe fornece muitos parâmetros ajustáveis e ganchos de extensibilidade. No entanto, os programadores são instados a usar os métodos Executors#newCachedThreadPool de fábrica mais convenientes Executors (pool de threads ilimitado, com recuperação automática de threads), Executors#newFixedThreadPool (pool de threads de tamanho fixo) e Executors#newSingleThreadExecutor (thread de plano de fundo único), que pré-configuram as configurações para os cenários de uso mais comuns. Caso contrário, use o seguinte guia ao configurar e ajustar manualmente essa classe:

<dl>

<dt>Core e tamanhos máximos de piscina/<dt>

<dd A ThreadPoolExecutor ajustará automaticamente o tamanho do pool (consulte #getPoolSize) de acordo com os limites definidos por corePoolSize (consulte #getCorePoolSize) e maximumPoolSize (consulte #getMaximumPoolSize).>

Quando uma nova tarefa é enviada no método #execute(Runnable), se menos de threads corePoolSize estiverem em execução, um novo thread será criado para manipular a solicitação, mesmo que outros threads de trabalho estejam ociosos. Caso contrário, se menos do que maximumPoolSize threads estiver em execução, um novo thread será criado para manipular a solicitação somente se a fila estiver cheia. Ao definir corePoolSize e maximumPoolSize da mesma forma, você cria um pool de threads de tamanho fixo. Ao definir maximumPoolSize como um valor essencialmente ilimitado, como Integer.MAX_VALUE, você permite que o pool acomode um número arbitrário de tarefas simultâneas. Na maioria das vezes, os tamanhos de núcleo e máximo da piscina são definidos apenas após a construção, mas também podem ser alterados dinamicamente usando #setCorePoolSize e #setMaximumPoolSize. </Dd>

<dt>Construção< sob demanda/dt>

<>dd Por padrão, até mesmo os threads principais são inicialmente criados e iniciados somente quando novas tarefas chegam, mas isso pode ser substituído dinamicamente usando método #prestartCoreThread ou #prestartAllCoreThreads. Você provavelmente deseja pré-iniciar threads se construir o pool com uma fila não vazia. </Dd>

<dt>Criando novos threads</dt>

<>dd Novos threads são criados usando um ThreadFactoryarquivo . Se não especificado de outra forma, um Executors#defaultThreadFactory é usado, que cria threads para que todos estejam no mesmo ThreadGroup e com o mesmo NORM_PRIORITY status de prioridade e não-daemon. Ao fornecer um ThreadFactory diferente, você pode alterar o nome do thread, o grupo de threads, a prioridade, o status do daemon, etc. Se um ThreadFactory falhar ao criar um thread quando solicitado retornando null de newThread, o executor continuará, mas talvez não consiga executar nenhuma tarefa. Os threads devem possuir o "modifyThread" RuntimePermission. Se os threads de trabalho ou outros threads que usam o pool não possuírem essa permissão, o serviço poderá ser degradado: as alterações de configuração podem não ter efeito em tempo hábil e um pool de desligamento pode permanecer em um estado no qual o encerramento é possível, mas não concluído.</Dd>

<dt>Tempos< de keep-alive/dt>

<>dd Se o pool tiver atualmente mais de threads corePoolSize, os threads em excesso serão encerrados se tiverem ficado ociosos por mais do que o keepAliveTime (consulte #getKeepAliveTime(TimeUnit)). Isso fornece um meio de reduzir o consumo de recursos quando o pool não está sendo usado ativamente. Se o pool se tornar mais ativo mais tarde, novos threads serão construídos. Esse parâmetro também pode ser alterado dinamicamente usando o método #setKeepAliveTime(long, TimeUnit). O uso de um valor de Long.MAX_VALUETimeUnit#NANOSECONDS efetivamente desativa threads ociosos de serem encerrados antes de serem desligados. Por padrão, a política keep-alive se aplica somente quando há mais de threads corePoolSize, mas o método #allowCoreThreadTimeOut(boolean) pode ser usado para aplicar essa política de tempo limite aos threads principais também, desde que o valor keepAliveTime seja diferente de zero. </Dd>

<dt>Enfileiramento</dt>

<>dd Qualquer BlockingQueue pode ser usado para transferir e manter tarefas enviadas. O uso dessa fila interage com o dimensionamento do pool:

<ul>

<li>Se menos de threads corePoolSize estiverem em execução, o Executor sempre prefere adicionar um novo thread em vez de enfileirar.

<li>Se corePoolSize ou mais threads estiverem em execução, o Executor sempre prefere enfileirar uma solicitação em vez de adicionar um novo thread.

<li>Se uma solicitação não puder ser enfileirada, um novo thread será criado, a menos que isso exceda maximumPoolSize, caso em que a tarefa será rejeitada.

</ul>

Existem três estratégias gerais para a fila: <>

<li><em> Transferências diretas.</em> Uma boa opção padrão para uma fila de trabalho é uma SynchronousQueue que entrega tarefas para threads sem mantê-las de outra forma. Aqui, uma tentativa de enfileirar uma tarefa falhará se nenhum thread estiver imediatamente disponível para executá-la, portanto, um novo thread será construído. Essa política evita bloqueios ao lidar com conjuntos de solicitações que podem ter dependências internas. As transferências diretas geralmente exigem máximoPoolSizes ilimitados para evitar a rejeição de novas tarefas enviadas. Isso, por sua vez, admite a possibilidade de crescimento ilimitado de threads quando os comandos continuam a chegar, em média, mais rápido do que podem ser processados.

<li><em> Filas ilimitadas.</em> Usar uma fila ilimitada (por exemplo, uma LinkedBlockingQueue sem uma capacidade predefinida) fará com que novas tarefas aguardem na fila quando todos os threads corePoolSize estiverem ocupados. Assim, não mais do que threads corePoolSize serão criados. (E o valor do maximumPoolSize, portanto, não tem nenhum efeito.) Isso pode ser apropriado quando cada tarefa é completamente independente de outras, de modo que as tarefas não podem afetar a execução umas das outras; por exemplo, em um servidor de página da Web. Embora esse estilo de enfileiramento possa ser útil para suavizar explosões transitórias de solicitações, ele admite a possibilidade de crescimento ilimitado da fila de trabalho quando os comandos continuam a chegar, em média, mais rápido do que podem ser processados.

<li><em>Filas limitadas.</em> Uma fila limitada (por exemplo, um ArrayBlockingQueue) ajuda a evitar a exaustão de recursos quando usada com máximos finitosPoolSizes, mas pode ser mais difícil de ajustar e controlar. Os tamanhos de fila e os tamanhos máximos de pool podem ser trocados uns pelos outros: o uso de filas grandes e pools pequenos minimiza o uso da CPU, os recursos do sistema operacional e a sobrecarga de alternância de contexto, mas pode levar a uma taxa de transferência artificialmente baixa. Se as tarefas forem bloqueadas com frequência (por exemplo, se estiverem vinculadas a E/S), um sistema poderá agendar o tempo para mais threads do que o permitido de outra forma. O uso de filas pequenas geralmente requer tamanhos de pool maiores, o que mantém as CPUs mais ocupadas, mas pode encontrar sobrecarga de agendamento inaceitável, o que também diminui a taxa de transferência.

</Ol>

</Dd>

<dt>Tarefas rejeitadas</dt>

<>dd Novas tarefas enviadas no método #execute(Runnable) serão <rejeitadas></em> quando o Executor tiver sido desligado e também quando o Executor usar limites finitos para threads máximos e capacidade da fila de trabalho, e estiver saturado. Em ambos os casos, o execute método invoca o RejectedExecutionHandler#rejectedExecution(Runnable, ThreadPoolExecutor) método de seu RejectedExecutionHandler. Quatro políticas de manipulador predefinidas são fornecidas:

<Ol>

<li>No padrão ThreadPoolExecutor.AbortPolicy, o manipulador lança um tempo de execução RejectedExecutionException após a rejeição.

<li>In ThreadPoolExecutor.CallerRunsPolicy, o thread que execute invoca a si mesmo executa a tarefa. Isso fornece um mecanismo de controle de feedback simples que diminuirá a taxa de envio de novas tarefas.

<li>In ThreadPoolExecutor.DiscardPolicy, uma tarefa que não pode ser executada é simplesmente descartada. Essa política é projetada apenas para os raros casos em que a conclusão da tarefa nunca é confiável.

<li>No ThreadPoolExecutor.DiscardOldestPolicy, se o executor não for desligado, a tarefa no topo da fila de trabalho será descartada e, em seguida, a execução será tentada novamente (o que pode falhar novamente, fazendo com que isso seja repetido). Esta política raramente é aceitável. Em quase todos os casos, você também deve cancelar a tarefa para causar uma exceção em qualquer componente que aguarda sua conclusão e/ou registrar a falha, conforme ilustrado na ThreadPoolExecutor.DiscardOldestPolicy documentação.

</Ol>

É possível definir e usar outros tipos de RejectedExecutionHandler classes. Fazer isso requer alguns cuidados, especialmente quando as políticas são projetadas para funcionar apenas sob políticas específicas de capacidade ou fila. </Dd>

<dt>Métodos< de gancho/dt>

<>dd Essa classe fornece protected métodos substituíveis #beforeExecute(Thread, Runnable) e #afterExecute(Runnable, Throwable) que são chamados antes e depois da execução de cada tarefa. Eles podem ser usados para manipular o ambiente de execução; por exemplo, reinicializando ThreadLocals, coletando estatísticas ou adicionando entradas de log. Além disso, o método #terminated pode ser substituído para executar qualquer processamento especial que precise ser feito depois que o Executor for totalmente encerrado.

Se os métodos hook, callback ou BlockingQueue lançarem exceções, os threads de trabalho internos poderão, por sua vez, falhar, encerrar abruptamente e, possivelmente, ser substituídos.</Dd>

<dt>Manutenção< de fila/dt>

<>O Método #getQueue() dd permite o acesso à fila de trabalho para fins de monitoramento e depuração. O uso deste método para qualquer outra finalidade é fortemente desencorajado. Dois métodos #remove(Runnable) fornecidos e #purge estão disponíveis para ajudar na recuperação de armazenamento quando um grande número de tarefas em fila é cancelado.</Dd>

<dt>Reclamação</dt>

<>dd Um pool que não é mais referenciado em um programa <em>AND</em> não tem threads restantes pode ser recuperado (lixo coletado) sem ser explicitamente desligado. Você pode configurar um pool para permitir que todos os threads não utilizados morram eventualmente definindo tempos de keep-alive apropriados, usando um limite inferior de zero core threads e/ou definindo #allowCoreThreadTimeOut(boolean). </Dd>

</Dl>

<b>Exemplo de extensão.</b> A maioria das extensões dessa classe substitui um ou mais dos métodos de gancho protegido. Por exemplo, aqui está uma subclasse que adiciona um recurso simples de pausa/retomada:

{@code
            class PausableThreadPoolExecutor extends ThreadPoolExecutor {
              private boolean isPaused;
              private ReentrantLock pauseLock = new ReentrantLock();
              private Condition unpaused = pauseLock.newCondition();

              public PausableThreadPoolExecutor(...) { super(...); }

              protected void beforeExecute(Thread t, Runnable r) {
                super.beforeExecute(t, r);
                pauseLock.lock();
                try {
                  while (isPaused) unpaused.await();
                } catch (InterruptedException ie) {
                  t.interrupt();
                } finally {
                  pauseLock.unlock();
                }
              }

              public void pause() {
                pauseLock.lock();
                try {
                  isPaused = true;
                } finally {
                  pauseLock.unlock();
                }
              }

              public void resume() {
                pauseLock.lock();
                try {
                  isPaused = false;
                  unpaused.signalAll();
                } finally {
                  pauseLock.unlock();
                }
              }
            }}

Adicionado em 1.5.

Documentação Java para java.util.concurrent.ThreadPoolExecutor.

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

Construtores

ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue)	Cria um novo ThreadPoolExecutor com os parâmetros iniciais fornecidos, a fábrica de threads padrão Executors#defaultThreadFactory e o ThreadPoolExecutor.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IRejectedExecutionHandler)	Cria um novo ThreadPoolExecutor com os parâmetros iniciais fornecidos e a fábrica de threads padrão Executors#defaultThreadFactory.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IThreadFactory)	Cria um novo ThreadPoolExecutor com os parâmetros iniciais fornecidos e o ThreadPoolExecutor.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IThreadFactory, IRejectedExecutionHandler)	Cria um novo ThreadPoolExecutor com os parâmetros iniciais fornecidos.
ThreadPoolExecutor(IntPtr, JniHandleOwnership)	Um construtor usado ao criar representações gerenciadas de objetos JNI; chamado pelo tempo de execução.

Propriedades

ActiveCount	Retorna o número aproximado de threads que estão executando tarefas ativamente.
Class	Retorna a classe de tempo de execução deste Object. (Herdado de Object)
CompletedTaskCount	Retorna o número total aproximado de tarefas que concluíram a execução.
CorePoolSize	Retorna o número principal de threads. -ou- Define o número principal de threads.
Handle	O identificador para a instância subjacente do Android. (Herdado de Object)
IsShutdown	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
IsTerminated	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
IsTerminating	Retorna true se esse executor estiver no processo de encerramento após #shutdown ou #shutdownNow mas não tiver terminado completamente.
JniIdentityHashCode	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
JniPeerMembers	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
LargestPoolSize	Retorna o maior número de threads que já estiveram simultaneamente no pool.
MaximumPoolSize	Retorna o número máximo permitido de threads. -ou- Define o número máximo permitido de threads.
PeerReference	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
PoolSize	Retorna o número atual de threads no pool.
Queue	Retorna a fila de tarefas usada por esse executor.
RejectedExecutionHandler	Retorna o manipulador atual para tarefas não executáveis. -ou- Define um novo manipulador para tarefas não executáveis.
TaskCount	Retorna o número total aproximado de tarefas que já foram agendadas para execução.
ThreadFactory	Retorna a fábrica de threads usada para criar novos threads. -ou- Define a fábrica de threads usada para criar novos threads.
ThresholdClass	Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código.
ThresholdType	Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código.

Métodos

AfterExecute(IRunnable, Throwable)	Método invocado após a conclusão da execução do Runnable fornecido.
AllowCoreThreadTimeOut(Boolean)	Define a política que rege se os threads principais podem atingir o tempo limite e terminar se nenhuma tarefa chegar dentro do tempo de manutenção, sendo substituídos se necessário quando novas tarefas chegarem.
AllowsCoreThreadTimeOut()	Retorna true se esse pool permitir que os threads principais atinjam o tempo limite e terminem se nenhuma tarefa chegar dentro do tempo keepAlive, sendo substituídos se necessário quando novas tarefas chegarem.
AwaitTermination(Int64, TimeUnit)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
AwaitTerminationAsync(Int64, TimeUnit)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
BeforeExecute(Thread, IRunnable)	Método invocado antes de executar o Runnable fornecido no thread fornecido.
Clone()	Cria e retorna uma cópia desse objeto. (Herdado de Object)
Dispose()	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
Dispose(Boolean)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
Equals(Object)	Indica se algum outro objeto é "igual" a este. (Herdado de Object)
Execute(IRunnable)	Executa a tarefa dada em algum momento no futuro.
GetHashCode()	Retorna um valor de código hash para o objeto. (Herdado de Object)
GetKeepAliveTime(TimeUnit)	Retorna o tempo de manutenção do thread, que é a quantidade de tempo que os threads podem permanecer ociosos antes de serem encerrados.
InvokeAll(ICollection)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
InvokeAll(ICollection, Int64, TimeUnit)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
InvokeAny(ICollection)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
InvokeAny(ICollection, Int64, TimeUnit)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
JavaFinalize()	Chamado pelo coletor de lixo em um objeto quando a coleta de lixo determina que não há mais referências ao objeto. (Herdado de Object)
NewTaskFor(ICallable)	Retorna um RunnableFuture para a determinada tarefa chamável. (Herdado de AbstractExecutorService)
NewTaskFor(IRunnable, Object)	Retorna a RunnableFuture para o determinado valor executável e padrão. (Herdado de AbstractExecutorService)
Notify()	Ativa um único thread que está aguardando no monitor deste objeto. (Herdado de Object)
NotifyAll()	Ativa todos os threads que estão aguardando no monitor deste objeto. (Herdado de Object)
PrestartAllCoreThreads()	Inicia todos os threads principais, fazendo com que eles esperem ociosamente pelo trabalho.
PrestartCoreThread()	Inicia um thread principal, fazendo com que ele aguarde ociosamente pelo trabalho.
Purge()	Tenta remover da fila de trabalho todas as Future tarefas que foram canceladas.
Remove(IRunnable)	Remove essa tarefa da fila interna do executor se ela estiver presente, fazendo com que ela não seja executada se ainda não tiver sido iniciada.
SetHandle(IntPtr, JniHandleOwnership)	Define a propriedade Handle. (Herdado de Object)
SetKeepAliveTime(Int64, TimeUnit)	Define o tempo de manutenção do thread, que é a quantidade de tempo que os threads podem permanecer ociosos antes de serem encerrados.
Shutdown()	Inicia um desligamento ordenado no qual as tarefas enviadas anteriormente são executadas, mas nenhuma nova tarefa será aceita.
ShutdownNow()	Tenta interromper todas as tarefas em execução ativa, interrompe o processamento de tarefas em espera e retorna uma lista das tarefas que estavam aguardando execução.
Submit(ICallable)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
Submit(IRunnable)	Envia uma tarefa Runnable para execução e retorna um Future representando essa tarefa. (Herdado de AbstractExecutorService)
Submit(IRunnable, Object)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de AbstractExecutorService)
Terminated()	Método invocado quando o Executor é encerrado.
ToArray<T>()	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
ToString()	Retorna uma representação de cadeia de caracteres do objeto. (Herdado de Object)
UnregisterFromRuntime()	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
Wait()	Faz com que o thread atual aguarde até que ele seja ativado, normalmente sendo <em notificado</em> ou <em>interrompido</em>>. (Herdado de Object)
Wait(Int64)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object)
Wait(Int64, Int32)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object)

Implantações explícitas de interface

IJavaPeerable.Disposed()	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
IJavaPeerable.DisposeUnlessReferenced()	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
IJavaPeerable.Finalized()	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
IJavaPeerable.JniManagedPeerState	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica. (Herdado de Object)

Métodos de Extensão

JavaCast<TResult>(IJavaObject)	Executa uma conversão de tipo verificada em tempo de execução do Android.
JavaCast<TResult>(IJavaObject)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
GetJniTypeName(IJavaPeerable)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
AwaitTerminationAsync(IExecutorService, Int64, TimeUnit)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
InvokeAnyAsync(IExecutorService, ICollection)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.
InvokeAnyAsync(IExecutorService, ICollection, Int64, TimeUnit)	Um ExecutorService que executa cada tarefa enviada usando um dos possivelmente vários threads em pool, normalmente configurados usando Executors métodos de fábrica.