ThreadPoolExecutor Clase

Definición

Espacio de nombres:

Java.Util.Concurrent

Ensamblado:

Mono.Android.dll

que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante 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

Herencia

Object

Object

AbstractExecutorService

ThreadPoolExecutor

Derivado

Java.Util.Concurrent.ScheduledThreadPoolExecutor

Atributos

RegisterAttribute

Comentarios

que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.

Los grupos de subprocesos abordan dos problemas diferentes: normalmente proporcionan un rendimiento mejorado al ejecutar un gran número de tareas asincrónicas, debido a una sobrecarga de invocación reducida por tarea, y proporcionan un medio de límite y administración de los recursos, incluidos los subprocesos, consumidos al ejecutar una colección de tareas. Cada ThreadPoolExecutor uno también mantiene algunas estadísticas básicas, como el número de tareas completadas.

Para ser útil en una amplia gama de contextos, esta clase proporciona muchos parámetros ajustables y enlaces de extensibilidad. Sin embargo, se insta a los programadores a usar los métodos de fábrica más convenientes ExecutorsExecutors#newCachedThreadPool (grupo de subprocesos sin enlazar, con recuperación automática de subprocesos), Executors#newFixedThreadPool (grupo de subprocesos de tamaño fijo) y Executors#newSingleThreadExecutor (subproceso en segundo plano único), que preconfiguran la configuración para los escenarios de uso más comunes. De lo contrario, use la siguiente guía al configurar y ajustar manualmente esta clase:

<dl>

<dt>Core y tamaños máximos< de grupo/dt>

<dd>A ThreadPoolExecutor ajustará automáticamente el tamaño del grupo (consulte #getPoolSize) según los límites establecidos por corePoolSize (consulte #getCorePoolSize) y maximumPoolSize (consulte #getMaximumPoolSize).

Cuando se envía una nueva tarea en el método #execute(Runnable), si se ejecutan menos de los subprocesos corePoolSize, se crea un nuevo subproceso para controlar la solicitud, incluso si otros subprocesos de trabajo están inactivos. De lo contrario, si se ejecutan menos de los subprocesos maximumPoolSize, se creará un nuevo subproceso para controlar la solicitud solo si la cola está llena. Al establecer corePoolSize y maximumPoolSize igual, se crea un grupo de subprocesos de tamaño fijo. Al establecer maximumPoolSize en un valor esencialmente sin enlazar, como Integer.MAX_VALUE, permite que el grupo admita un número arbitrario de tareas simultáneas. Normalmente, los tamaños de grupo máximo y núcleo se establecen solo en la construcción, pero también se pueden cambiar dinámicamente mediante #setCorePoolSize y #setMaximumPoolSize. </Dd>

<dt>On-demand construction</dt>

<dd>De forma predeterminada, incluso los subprocesos principales se crean inicialmente e inician solo cuando llegan nuevas tareas, pero esto se puede invalidar dinámicamente mediante el método #prestartCoreThread o #prestartAllCoreThreads. Probablemente quiera preinicio de subprocesos si crea el grupo con una cola no vacía. </Dd>

<dt>Creating new threads</dt>

<>Los subprocesos nuevos se crean mediante .ThreadFactory Si no se especifica lo contrario, se usa un Executors#defaultThreadFactory objeto que crea subprocesos para que todos estén en el mismo ThreadGroup estado y con la misma NORM_PRIORITY prioridad y sin demonio. Al proporcionar un threadFactory diferente, puede modificar el nombre del subproceso, el grupo de subprocesos, la prioridad, el estado del demonio, etc. Si no ThreadFactory se puede crear un subproceso cuando se le pida que devuelva null desde newThread, el ejecutor continuará, pero es posible que no pueda ejecutar ninguna tarea. Los subprocesos deben poseer el elemento "modifyThread". RuntimePermission Si los subprocesos de trabajo u otros subprocesos que usan el grupo no poseen este permiso, el servicio se puede degradar: es posible que los cambios de configuración no surtan efecto de forma oportuna y un grupo de apagado puede permanecer en un estado en el que la terminación es posible pero no completada.</Dd>

<dt>Keep-alive times</dt>

<dd>Si el grupo tiene actualmente más de los subprocesos corePoolSize, se finalizará el exceso de subprocesos si han estado inactivos durante más de keepAliveTime (consulte #getKeepAliveTime(TimeUnit)). Esto proporciona un medio para reducir el consumo de recursos cuando el grupo no se usa activamente. Si el grupo se vuelve más activo más adelante, se construirán nuevos subprocesos. Este parámetro también se puede cambiar dinámicamente mediante el método #setKeepAliveTime(long, TimeUnit). El uso de un valor de Long.MAX_VALUETimeUnit#NANOSECONDS deshabilita eficazmente que los subprocesos inactivos terminen nunca antes de apagarse. De forma predeterminada, la directiva keep-alive solo se aplica cuando hay más que los subprocesos corePoolSize, pero se puede usar el método #allowCoreThreadTimeOut(boolean) para aplicar esta directiva de tiempo de espera a los subprocesos principales, siempre y cuando el valor keepAliveTime sea distinto de cero. </Dd>

<dt>Queuing</dt>

<dd>Cualquier BlockingQueue se puede usar para transferir y retener tareas enviadas. El uso de esta cola interactúa con el ajuste de tamaño del grupo:

<ul>

<li>Si se ejecutan menos de corePoolSize subprocesos, Executor siempre prefiere agregar un nuevo subproceso en lugar de poner en cola.

<li>Si corePoolSize o más subprocesos se están ejecutando, executor siempre prefiere poner en cola una solicitud en lugar de agregar un nuevo subproceso.

<li>Si no se puede poner en cola una solicitud, se crea un nuevo subproceso a menos que esto supere maximumPoolSize, en cuyo caso se rechazará la tarea.

</ul>

Hay tres estrategias generales para poner en cola: <ol>

<li><em> Direct handoffs.</em> Una buena opción predeterminada para una cola de trabajo es una SynchronousQueue que entrega las tareas a los subprocesos sin mantenerlas de otro modo. En este caso, se producirá un error en un intento de poner en cola una tarea si no hay subprocesos disponibles inmediatamente para ejecutarla, por lo que se construirá un nuevo subproceso. Esta directiva evita bloqueos al controlar conjuntos de solicitudes que podrían tener dependencias internas. Por lo general, las entregas directas requieren maximumPoolSizes sin enlazar para evitar el rechazo de las nuevas tareas enviadas. Esto a su vez admite la posibilidad de crecimiento de subprocesos sin enlazar cuando los comandos siguen llegando en promedio más rápido de lo que se pueden procesar.

<li><em> Colas sin enlazar.</em> Usar una cola sin enlazar (por ejemplo, sin LinkedBlockingQueue una capacidad predefinida) hará que las nuevas tareas esperen en la cola cuando todos los subprocesos corePoolSize estén ocupados. Por lo tanto, nunca se crearán más subprocesos corePoolSize. (Y el valor de maximumPoolSize, por lo tanto, no tiene ningún efecto). Esto puede ser adecuado cuando cada tarea es completamente independiente de otras, por lo que las tareas no pueden afectar a la ejecución entre sí; por ejemplo, en un servidor de páginas web. Aunque este estilo de puesta en cola puede ser útil para suavizar las ráfagas transitorias de solicitudes, admite la posibilidad de crecimiento de colas de trabajo sin enlazar cuando los comandos siguen llegando en promedio más rápido de lo que se pueden procesar.

<li><em>Colas limitadas.</em> Una cola limitada (por ejemplo, un ArrayBlockingQueue) ayuda a evitar el agotamiento de recursos cuando se usa con maximumPoolSizes finito, pero puede ser más difícil ajustar y controlar. Los tamaños de cola y los tamaños máximos de grupo se pueden intercambiar entre sí: el uso de colas grandes y grupos pequeños minimiza el uso de CPU, los recursos del sistema operativo y la sobrecarga de cambio de contexto, pero puede dar lugar a un rendimiento artificialmente bajo. Si las tareas suelen bloquear (por ejemplo, si están enlazadas a E/S), es posible que un sistema pueda programar el tiempo de más subprocesos que permitir. El uso de colas pequeñas normalmente requiere tamaños de grupo más grandes, lo que mantiene las CPU más ocupados, pero puede encontrar una sobrecarga de programación inaceptable, lo que también reduce el rendimiento.

</Ol>

</Dd>

<dt>Tareas rechazadas</dt>

<dd>New tasks submitted in method #execute(Runnable) will <em>rejected</em> when the Executor has been shut down, and also when the Executor uses finite bounds for maximum threads and work queue capacity, and is saturado. En cualquier caso, el execute método invoca el RejectedExecutionHandler#rejectedExecution(Runnable, ThreadPoolExecutor) método de su RejectedExecutionHandler. Se proporcionan cuatro directivas de controlador predefinidas:

<Ol>

<li>En el valor predeterminado ThreadPoolExecutor.AbortPolicy, el controlador produce un tiempo de ejecución RejectedExecutionException tras el rechazo.

<li>En ThreadPoolExecutor.CallerRunsPolicy, el subproceso execute que invoca a sí mismo ejecuta la tarea. Esto proporciona un mecanismo de control de comentarios sencillo que ralentizará la velocidad en la que se envían nuevas tareas.

<li>En ThreadPoolExecutor.DiscardPolicy, una tarea que no se puede ejecutar simplemente se quita. Esta directiva está diseñada solo para aquellos casos excepcionales en los que nunca se basa la finalización de tareas.

<li>En ThreadPoolExecutor.DiscardOldestPolicy, si el ejecutor no se cierra, se quita la tarea en el encabezado de la cola de trabajo y, a continuación, se reintenta la ejecución (lo que puede producir un error de nuevo, lo que hace que esto se repita). Esta directiva rara vez es aceptable. En casi todos los casos, también debe cancelar la tarea para provocar una excepción en cualquier componente esperando su finalización o registrar el error, como se muestra en ThreadPoolExecutor.DiscardOldestPolicy la documentación.

</Ol>

Es posible definir y usar otros tipos de RejectedExecutionHandler clases. Esto requiere cierta atención especialmente cuando las directivas están diseñadas para funcionar solo con directivas de puesta en cola o capacidad concretas. </Dd>

<métodos< dt>Hook/dt>

<dd>Esta clase proporciona protected métodos y #afterExecute(Runnable, Throwable) reemplazables #beforeExecute(Thread, Runnable) a los que se llama antes y después de la ejecución de cada tarea. Se pueden usar para manipular el entorno de ejecución; por ejemplo, reinicializando ThreadLocals, recopilando estadísticas o agregando entradas de registro. Además, se puede invalidar el método #terminated para realizar cualquier procesamiento especial que deba realizarse una vez que el Ejecutor haya terminado por completo.

Si los métodos hook, callback o BlockingQueue inician excepciones, los subprocesos de trabajo internos pueden producir errores, finalizar repentinamente y, posiblemente, reemplazarse.</Dd>

<dt>Queue maintenance</dt>

<El método #getQueue() dd>permite el acceso a la cola de trabajo con fines de supervisión y depuración. Se recomienda encarecidamente el uso de este método para cualquier otro propósito. Dos métodos proporcionados #remove(Runnable) y #purge están disponibles para ayudar en la recuperación del almacenamiento cuando se cancelan grandes cantidades de tareas en cola.</Dd>

<dt>Reclamation</dt>

<dd>Un grupo al que ya no se hace referencia en un programa <em>AND</em> no tiene subprocesos restantes se puede reclamar (recolección de elementos no utilizados) sin cerrarse explícitamente. Puede configurar un grupo para permitir que todos los subprocesos sin usar se mueran estableciendo los tiempos de mantenimiento adecuados mediante un límite inferior de los subprocesos de núcleo cero o estableciendo #allowCoreThreadTimeOut(boolean). </Dd>

</Dl>

<b>Ejemplo de extensión.</b> La mayoría de las extensiones de esta clase invalidan uno o varios de los métodos de enlace protegidos. Por ejemplo, esta es una subclase que agrega una característica simple de pausa/reanudación:

{@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();
                }
              }
            }}

Agregado en 1.5.

Documentación de Java para java.util.concurrent.ThreadPoolExecutor.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el proyecto de código abierto de Android y se usan según los términos descritos en la licencia de atribución de Creative Commons 2.5.

Constructores

ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue)	Crea un nuevo ThreadPoolExecutor con los parámetros iniciales especificados, el generador de subprocesos predeterminado Executors#defaultThreadFactory y ThreadPoolExecutor.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IRejectedExecutionHandler)	Crea un nuevo ThreadPoolExecutor con los parámetros iniciales especificados y el generador de subprocesos predeterminado Executors#defaultThreadFactory.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IThreadFactory)	Crea un nuevo ThreadPoolExecutor con los parámetros iniciales especificados y ThreadPoolExecutor.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IThreadFactory, IRejectedExecutionHandler)	Crea un nuevo ThreadPoolExecutor con los parámetros iniciales especificados.
ThreadPoolExecutor(IntPtr, JniHandleOwnership)	Constructor utilizado al crear representaciones administradas de objetos JNI; llamado por el tiempo de ejecución.

Propiedades

ActiveCount	Devuelve el número aproximado de subprocesos que ejecutan activamente tareas.
Class	Devuelve la clase en tiempo de ejecución de este Objectobjeto . (Heredado de Object)
CompletedTaskCount	Devuelve el número total aproximado de tareas que han completado la ejecución.
CorePoolSize	Devuelve el número principal de subprocesos. -o bien- Establece el número principal de subprocesos.
Handle	Identificador de la instancia de Android subyacente. (Heredado de Object)
IsShutdown	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
IsTerminated	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
IsTerminating	Devuelve true si este ejecutor está en proceso de terminación después #shutdown de o #shutdownNow pero no ha terminado completamente.
JniIdentityHashCode	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
JniPeerMembers	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
LargestPoolSize	Devuelve el mayor número de subprocesos que se han estado simultáneamente en el grupo.
MaximumPoolSize	Devuelve el número máximo permitido de subprocesos. -o bien- Establece el número máximo permitido de subprocesos.
PeerReference	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
PoolSize	Devuelve el número actual de subprocesos del grupo.
Queue	Devuelve la cola de tareas usada por este ejecutor.
RejectedExecutionHandler	Devuelve el controlador actual para tareas no ejecutables. -o bien- Establece un nuevo controlador para tareas no ejecutables.
TaskCount	Devuelve el número total aproximado de tareas que se han programado para su ejecución.
ThreadFactory	Devuelve el generador de subprocesos usado para crear nuevos subprocesos. -o bien- Establece el generador de subprocesos usado para crear nuevos subprocesos.
ThresholdClass	Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código.
ThresholdType	Esta API admite la infraestructura mono para Android y no está pensada para usarse directamente desde el código.

Métodos

AfterExecute(IRunnable, Throwable)	Método invocado tras la finalización de la ejecución del runnable especificado.
AllowCoreThreadTimeOut(Boolean)	Establece la directiva que rige si los subprocesos principales pueden agotar el tiempo de espera y finalizar si no llegan tareas dentro del tiempo de mantenimiento, y se reemplazan si es necesario cuando llegan nuevas tareas.
AllowsCoreThreadTimeOut()	Devuelve true si este grupo permite que los subprocesos principales agoten el tiempo de espera y finalicen si no llegan tareas dentro del tiempo keepAlive y se reemplazan si es necesario cuando llegan nuevas tareas.
AwaitTermination(Int64, TimeUnit)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
AwaitTerminationAsync(Int64, TimeUnit)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
BeforeExecute(Thread, IRunnable)	Método invocado antes de ejecutar el runnable especificado en el subproceso especificado.
Clone()	Crea y devuelve una copia de este objeto. (Heredado de Object)
Dispose()	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
Dispose(Boolean)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
Equals(Object)	Indica si algún otro objeto es "igual a" este. (Heredado de Object)
Execute(IRunnable)	Ejecuta la tarea especificada en algún momento en el futuro.
GetHashCode()	Devuelve un valor de código hash del objeto. (Heredado de Object)
GetKeepAliveTime(TimeUnit)	Devuelve el tiempo de mantenimiento del subproceso, que es la cantidad de tiempo que los subprocesos pueden permanecer inactivos antes de finalizarse.
InvokeAll(ICollection)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
InvokeAll(ICollection, Int64, TimeUnit)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
InvokeAny(ICollection)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
InvokeAny(ICollection, Int64, TimeUnit)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
JavaFinalize()	Lo llama el recolector de elementos no utilizados en un objeto cuando la recolección de elementos no utilizados determina que no hay más referencias al objeto . (Heredado de Object)
NewTaskFor(ICallable)	Devuelve un RunnableFuture para la tarea invocable especificada. (Heredado de AbstractExecutorService)
NewTaskFor(IRunnable, Object)	Devuelve un RunnableFuture para el valor runnable y predeterminado especificados. (Heredado de AbstractExecutorService)
Notify()	Activa un único subproceso que está esperando en el monitor de este objeto. (Heredado de Object)
NotifyAll()	Activa todos los subprocesos que están esperando en el monitor de este objeto. (Heredado de Object)
PrestartAllCoreThreads()	Inicia todos los subprocesos principales, lo que hace que esperen de forma idíca el trabajo.
PrestartCoreThread()	Inicia un subproceso principal, lo que hace que espere de forma idíca el trabajo.
Purge()	Intenta quitar de la cola de trabajo todas las Future tareas que se han cancelado.
Remove(IRunnable)	Quita esta tarea de la cola interna del ejecutor si está presente, lo que hace que no se ejecute si aún no se ha iniciado.
SetHandle(IntPtr, JniHandleOwnership)	Establece la propiedad Handle. (Heredado de Object)
SetKeepAliveTime(Int64, TimeUnit)	Establece el tiempo de mantenimiento del subproceso, que es la cantidad de tiempo que los subprocesos pueden permanecer inactivos antes de finalizarse.
Shutdown()	Inicia un apagado ordenado en el que se ejecutan las tareas enviadas anteriormente, pero no se aceptarán nuevas tareas.
ShutdownNow()	Intenta detener todas las tareas que se ejecutan activamente, detiene el procesamiento de tareas en espera y devuelve una lista de las tareas que estaban esperando la ejecución.
Submit(ICallable)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
Submit(IRunnable)	Envía una tarea runnable para su ejecución y devuelve un valor Future que representa esa tarea. (Heredado de AbstractExecutorService)
Submit(IRunnable, Object)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de AbstractExecutorService)
Terminated()	Método invocado cuando el Ejecutor ha finalizado.
ToArray<T>()	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
ToString()	Devuelve una representación de cadena del objeto. (Heredado de Object)
UnregisterFromRuntime()	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
Wait()	Hace que el subproceso actual espere hasta que se despierta, normalmente por ser em notificado/em> o <em>interrumpido</em>.<>< (Heredado de Object)
Wait(Int64)	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object)
Wait(Int64, Int32)	Hace que el subproceso actual espere hasta que se despierte, normalmente por ser <em>notificado</em> o <em>interrumpido</em>, o hasta que haya transcurrido una cierta cantidad de tiempo real. (Heredado de Object)

Implementaciones de interfaz explícitas

IJavaPeerable.Disposed()	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
IJavaPeerable.DisposeUnlessReferenced()	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
IJavaPeerable.Finalized()	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
IJavaPeerable.JniManagedPeerState	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica. (Heredado de Object)

Métodos de extensión

JavaCast<TResult>(IJavaObject)	Realiza una conversión de tipos comprobados en tiempo de ejecución de Android.
JavaCast<TResult>(IJavaObject)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
GetJniTypeName(IJavaPeerable)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
AwaitTerminationAsync(IExecutorService, Int64, TimeUnit)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
InvokeAnyAsync(IExecutorService, ICollection)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.
InvokeAnyAsync(IExecutorService, ICollection, Int64, TimeUnit)	que ExecutorService ejecuta cada tarea enviada mediante uno de los subprocesos agrupados, normalmente configurados mediante Executors métodos de fábrica.