ThreadPoolExecutor Classe

Riferimento

Definizione

Spazio dei nomi:: Java.Util.Concurrent

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Oggetto ExecutorService che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando Executors i metodi factory.

[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

Ereditarietà: Object

Object

AbstractExecutorService
ThreadPoolExecutor

Derivato: Java.Util.Concurrent.ScheduledThreadPoolExecutor

Attributi: RegisterAttribute

Commenti

Oggetto ExecutorService che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando Executors i metodi factory.

I pool di thread rispondono a due diversi problemi: in genere offrono prestazioni migliorate durante l'esecuzione di un numero elevato di attività asincrone, a causa di un sovraccarico di chiamata per attività ridotto e forniscono un mezzo di delimitazione e gestione delle risorse, inclusi i thread, utilizzati durante l'esecuzione di una raccolta di attività. Ognuna ThreadPoolExecutor mantiene anche alcune statistiche di base, ad esempio il numero di attività completate.

Per essere utile in un'ampia gamma di contesti, questa classe fornisce molti parametri regolabili e hook di estendibilità. Tuttavia, i programmatori sono invitati a usare i metodi Executors#newCachedThreadPool factory più pratici Executors (pool di thread non associati, con il recupero automatico dei thread), Executors#newFixedThreadPool (pool di thread a dimensione fissa) e Executors#newSingleThreadExecutor (thread in background singolo), che preconfigurano le impostazioni per gli scenari di utilizzo più comuni. In caso contrario, usare la guida seguente quando si configura e si ottimizza manualmente questa classe:

<dl>

<dt>Core e dimensioni massime del< pool/dt>

<dd>A ThreadPoolExecutor regola automaticamente le dimensioni del pool (vedere #getPoolSize) in base ai limiti impostati da corePoolSize (vedere #getCorePoolSize) e maximumPoolSize (vedere #getMaximumPoolSize).

Quando viene inviata una nuova attività nel metodo #execute(Runnable), se sono in esecuzione meno thread corePoolSize, viene creato un nuovo thread per gestire la richiesta, anche se altri thread di lavoro sono inattive. In caso contrario, se sono in esecuzione meno thread maximumPoolSize, verrà creato un nuovo thread per gestire la richiesta solo se la coda è piena. Impostando corePoolSize e maximumPoolSize, si crea un pool di thread a dimensione fissa. Impostando maximumPoolSize su un valore essenzialmente non associato, ad Integer.MAX_VALUEesempio , si consente al pool di contenere un numero arbitrario di attività simultanee. La maggior parte delle dimensioni del pool core e massimo viene in genere impostata solo in fase di costruzione, ma può anche essere modificata in modo dinamico usando #setCorePoolSize e #setMaximumPoolSize. </Dd>

<dt>Costruzione< on demand/dt>

<dd>Per impostazione predefinita, anche i thread core vengono inizialmente creati e avviati solo quando arrivano nuove attività, ma questo può essere sottoposto a override in modo dinamico usando il metodo #prestartCoreThread o #prestartAllCoreThreads. È probabile che si voglia preavvio dei thread se si costruisce il pool con una coda non vuota. </Dd>

<dt>Creazione di nuovi thread</dt>

<dd>I nuovi thread vengono creati usando un oggetto ThreadFactory. Se non specificato diversamente, viene usato un oggetto Executors#defaultThreadFactory che crea thread per tutti nello stesso ThreadGroup e con la stessa priorità e lo stato NORM_PRIORITY non daemon. Fornendo un threadFactory diverso, è possibile modificare il nome, il gruppo di thread, la priorità, lo stato del daemon e così via. Se un oggetto ThreadFactory non riesce a creare un thread quando richiesto restituendo null da newThread, l'executor continuerà, ma potrebbe non essere in grado di eseguire alcuna attività. I thread devono possedere l'oggetto "modifyThread". RuntimePermission Se i thread di lavoro o altri thread che usano il pool non possiedono questa autorizzazione, il servizio potrebbe essere danneggiato: le modifiche alla configurazione potrebbero non essere applicate in modo tempestivo e un pool di arresto potrebbe rimanere in uno stato in cui la terminazione è possibile ma non completata.</Dd>

<dt>Keep-alive times</dt>

<dd>Se il pool dispone attualmente di più di thread corePoolSize, i thread in eccesso verranno terminati se sono stati inattivi per più di keepAliveTime (vedere #getKeepAliveTime(TimeUnit)). Ciò consente di ridurre il consumo di risorse quando il pool non viene usato attivamente. Se il pool diventa più attivo in un secondo momento, verranno costruiti nuovi thread. Questo parametro può anche essere modificato in modo dinamico usando il metodo #setKeepAliveTime(long, TimeUnit). L'uso di un valore di disabilita in modo efficace i thread inattive mai terminati prima dell'arresto Long.MAX_VALUETimeUnit#NANOSECONDS . Per impostazione predefinita, il criterio keep-alive si applica solo quando sono presenti più thread corePoolSize, ma il metodo #allowCoreThreadTimeOut(boolean) può essere usato per applicare questo criterio di timeout anche ai thread principali, purché il valore keepAliveTime sia diverso da zero. </Dd>

<dt>Accodamento</dt>

<dd>Qualsiasi BlockingQueue può essere usato per trasferire e conservare le attività inviate. L'uso di questa coda interagisce con il dimensionamento del pool:

<ul>

<li>Se sono in esecuzione meno thread corePoolSize, l'executor preferisce sempre aggiungere un nuovo thread anziché accodare.

<li>Se corePoolSize o più thread sono in esecuzione, l'executor preferisce sempre accodare una richiesta anziché aggiungere un nuovo thread.

<li>Se non è possibile accodare una richiesta, viene creato un nuovo thread a meno che non superi maximumPoolSize, nel qual caso l'attività verrà rifiutata.

</ul>

Esistono tre strategie generali per l'accodamento: <ol>

<li> Direct handoffs. Una buona scelta predefinita per una coda di lavoro è un oggetto SynchronousQueue che distribuisce le attività ai thread senza tenerle in altro modo. In questo caso, un tentativo di accodare un'attività avrà esito negativo se non sono immediatamente disponibili thread per eseguirlo, quindi verrà costruito un nuovo thread. Questo criterio evita i blocchi durante la gestione di set di richieste che potrebbero avere dipendenze interne. Gli handoff diretti richiedono in genere valori massimi non associatiPoolSizes per evitare il rifiuto delle nuove attività inviate. Ciò a sua volta ammette la possibilità di crescita dei thread non associati quando i comandi continuano ad arrivare in media più velocemente di quanto possano essere elaborati.

<li> Code non associate. L'uso di una coda non associato (ad esempio, senza LinkedBlockingQueue una capacità predefinita) causerà l'attesa di nuove attività nella coda quando tutti i thread corePoolSize sono occupati. Pertanto, non verranno mai creati più thread corePoolSize. E il valore di maximumPoolSize non ha alcun effetto. Questo può essere appropriato quando ogni attività è completamente indipendente da altre, quindi le attività non possono influire su ognuna delle altre esecuzioni; ad esempio, in un server di pagine Web. Anche se questo stile di accodamento può essere utile per smussare i picchi temporanei di richieste, ammette la possibilità di crescita della coda di lavoro non associato quando i comandi continuano ad arrivare in media più velocemente di quanto possano essere elaborati.

<li>Code delimitate. Una coda delimitata (ad esempio, un ArrayBlockingQueue) consente di evitare l'esaurimento delle risorse quando viene usato con maximumPoolSizes finito, ma può essere più difficile da ottimizzare e controllare. Le dimensioni delle code e le dimensioni massime del pool possono essere scambiate tra loro: l'uso di code di grandi dimensioni e pool di piccole dimensioni riduce al minimo l'utilizzo della CPU, le risorse del sistema operativo e il sovraccarico del cambio di contesto, ma può portare a una velocità effettiva artificialmente bassa. Se le attività vengono bloccate di frequente(ad esempio se sono associate a I/O), un sistema potrebbe essere in grado di pianificare l'ora per più thread rispetto a quanto altrimenti consentito. L'uso di code di piccole dimensioni richiede in genere dimensioni maggiori del pool, che mantiene le CPU più bussante, ma può riscontrare un sovraccarico di pianificazione inaccettabile, riducendo anche la velocità effettiva.

</olo>

</Dd>

<dt>Attività rifiutate</dt>

<dd>Nuove attività inviate nel metodo #execute(Runnable) verranno <>rifiutate quando l'executor è stato arrestato e anche quando l'executor usa limiti finiti per thread massimi e capacità della coda di lavoro ed è saturo. In entrambi i casi, il execute metodo richiama il RejectedExecutionHandler#rejectedExecution(Runnable, ThreadPoolExecutor) metodo del relativo RejectedExecutionHandleroggetto . Vengono forniti quattro criteri del gestore predefiniti:

<olo>

<li>Nel valore predefinito ThreadPoolExecutor.AbortPolicy, il gestore genera un runtime RejectedExecutionException al rifiuto.

<li>In ThreadPoolExecutor.CallerRunsPolicy, il thread che richiama execute se stesso esegue l'attività. In questo modo viene fornito un semplice meccanismo di controllo dei commenti e suggerimenti che rallenta la frequenza di invio delle nuove attività.

<li>In ThreadPoolExecutor.DiscardPolicy, un'attività che non può essere eseguita viene semplicemente eliminata. Questo criterio è progettato solo per i rari casi in cui il completamento delle attività non si basa mai.

<li>In ThreadPoolExecutor.DiscardOldestPolicy, se l'executor non viene arrestato, l'attività all'inizio della coda di lavoro viene eliminata e quindi viene ritentata l'esecuzione (che può non riuscire di nuovo, causando la ripetizione di questa operazione). Questo criterio è raramente accettabile. In quasi tutti i casi, è anche necessario annullare l'attività per causare un'eccezione in qualsiasi componente in attesa del completamento e/o registrare l'errore, come illustrato nella ThreadPoolExecutor.DiscardOldestPolicy documentazione.

</olo>

È possibile definire e usare altri tipi di RejectedExecutionHandler classi. In questo modo è necessario prestare particolare attenzione quando i criteri sono progettati per funzionare solo in particolari criteri di accodamento o capacità. </Dd>

<dt>Hook methods</dt>

<dd>Questa classe fornisce protected metodi e #afterExecute(Runnable, Throwable) sottoponibili a override #beforeExecute(Thread, Runnable) chiamati prima e dopo l'esecuzione di ogni attività. Questi possono essere usati per modificare l'ambiente di esecuzione; ad esempio reinizializzare ThreadLocals, raccogliere statistiche o aggiungere voci di log. Inoltre, è possibile eseguire l'override del metodo #terminated per eseguire qualsiasi elaborazione speciale che deve essere eseguita dopo che l'executor ha terminato completamente.

Se i metodi hook, callback o BlockingQueue generano eccezioni, i thread di lavoro interni possono a loro volta non riuscire, terminare bruscamente ed eventualmente essere sostituiti.</Dd>

<dt>Queue maintenance</dt>

<Il metodo #getQueue() dd>consente l'accesso alla coda di lavoro ai fini del monitoraggio e del debug. L'uso di questo metodo per qualsiasi altro scopo è fortemente sconsigliato. Due metodi #remove(Runnable) forniti e #purge sono disponibili per facilitare il recupero dell'archiviazione quando un numero elevato di attività in coda viene annullato.</Dd>

<dt>Reclamation</dt>

<dd>Un pool a cui non viene più fatto riferimento in un programma> non dispone di thread rimanenti può essere recuperato (Garbage Collection) senza essere arrestato in modo esplicito. È possibile configurare un pool per consentire a tutti i thread inutilizzati di morire impostando i tempi keep-alive appropriati, usando un limite inferiore di thread core zero e/o impostando #allowCoreThreadTimeOut(boolean). </Dd>

</Dl>

Esempio di estensione. La maggior parte delle estensioni di questa classe esegue l'override di uno o più metodi hook protetti. Ecco ad esempio una sottoclasse che aggiunge una semplice funzionalità di sospensione/ripresa:

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

Aggiunto nella versione 1.5.

Documentazione java per java.util.concurrent.ThreadPoolExecutor.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Costruttori

ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue)	Crea un nuovo `ThreadPoolExecutor` oggetto con i parametri iniziali specificati, la factory di thread predefinita Executors#defaultThreadFactory e ThreadPoolExecutor.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IRejectedExecutionHandler)	Crea un nuovo `ThreadPoolExecutor` oggetto con i parametri iniziali specificati e la factory di thread predefinita Executors#defaultThreadFactory.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IThreadFactory)	Crea un nuovo `ThreadPoolExecutor` oggetto con i parametri iniziali specificati e ThreadPoolExecutor.
ThreadPoolExecutor(Int32, Int32, Int64, TimeUnit, IBlockingQueue, IThreadFactory, IRejectedExecutionHandler)	Crea un nuovo `ThreadPoolExecutor` oggetto con i parametri iniziali specificati.
ThreadPoolExecutor(IntPtr, JniHandleOwnership)	Costruttore usato durante la creazione di rappresentazioni gestite di oggetti JNI; chiamato dal runtime.

Proprietà

ActiveCount	Restituisce il numero approssimativo di thread che eseguono attivamente attività.
Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
CompletedTaskCount	Restituisce il numero totale approssimativo di attività che hanno completato l'esecuzione.
CorePoolSize	Restituisce il numero di core di thread. -oppure- Imposta il numero di core di thread.
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
IsShutdown	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
IsTerminated	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
IsTerminating	Restituisce true se questo executor è in corso di terminazione dopo `#shutdown` o `#shutdownNow` ma non è stato terminato completamente.
JniIdentityHashCode	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
JniPeerMembers	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
LargestPoolSize	Restituisce il maggior numero di thread che sono mai stati contemporaneamente nel pool.
MaximumPoolSize	Restituisce il numero massimo consentito di thread. -oppure- Imposta il numero massimo consentito di thread.
PeerReference	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
PoolSize	Restituisce il numero corrente di thread nel pool.
Queue	Restituisce la coda di attività utilizzata da questo executor.
RejectedExecutionHandler	Restituisce il gestore corrente per le attività non eseguibili. -oppure- Imposta un nuovo gestore per le attività non eseguibili.
TaskCount	Restituisce il numero totale approssimativo di attività che sono state pianificate per l'esecuzione.
ThreadFactory	Restituisce la factory thread utilizzata per creare nuovi thread. -oppure- Imposta la factory thread usata per creare nuovi thread.
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice.

Metodi

AfterExecute(IRunnable, Throwable)	Metodo richiamato al completamento dell'esecuzione dell'oggetto Runnable specificato.
AllowCoreThreadTimeOut(Boolean)	Imposta i criteri che regolano se i thread principali possono scadere e terminare se non arrivano attività entro il tempo keep-alive, in caso di necessità quando arrivano nuove attività.
AllowsCoreThreadTimeOut()	Restituisce true se questo pool consente ai thread principali di scadere e terminare se non arrivano attività entro il periodo di tempo keepAlive, se necessario quando arrivano nuove attività.
AwaitTermination(Int64, TimeUnit)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
AwaitTerminationAsync(Int64, TimeUnit)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
BeforeExecute(Thread, IRunnable)	Metodo richiamato prima di eseguire l'oggetto Runnable specificato nel thread specificato.
Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
Dispose(Boolean)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
Execute(IRunnable)	Esegue l'attività specificata in futuro.
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
GetKeepAliveTime(TimeUnit)	Restituisce il tempo keep-alive del thread, ovvero la quantità di tempo in cui i thread possono rimanere inattive prima di essere terminati.
InvokeAll(ICollection)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
InvokeAll(ICollection, Int64, TimeUnit)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
InvokeAny(ICollection)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
InvokeAny(ICollection, Int64, TimeUnit)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
NewTaskFor(ICallable)	Restituisce un oggetto `RunnableFuture` per l'attività chiamabile specificata. (Ereditato da AbstractExecutorService)
NewTaskFor(IRunnable, Object)	Restituisce un `RunnableFuture` oggetto per il valore predefinito e eseguibile specificato. (Ereditato da AbstractExecutorService)
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object)
PrestartAllCoreThreads()	Avvia tutti i thread principali, causando l'attesa inattiva del lavoro.
PrestartCoreThread()	Avvia un thread principale, causando l'attesa inattiva del lavoro.
Purge()	Prova a rimuovere dalla coda di lavoro tutte le `Future` attività annullate.
Remove(IRunnable)	Rimuove questa attività dalla coda interna dell'executor, se presente, in modo che non venga eseguita se non è già stata avviata.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
SetKeepAliveTime(Int64, TimeUnit)	Imposta il tempo keep-alive del thread, ovvero la quantità di tempo in cui i thread possono rimanere inattive prima di essere terminati.
Shutdown()	Avvia un arresto ordinato in cui vengono eseguite le attività inviate in precedenza, ma non verranno accettate nuove attività.
ShutdownNow()	Tenta di arrestare tutte le attività in esecuzione attivamente, interrompe l'elaborazione delle attività in attesa e restituisce un elenco delle attività in attesa dell'esecuzione.
Submit(ICallable)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
Submit(IRunnable)	Invia un'attività eseguibile per l'esecuzione e restituisce un oggetto Future che rappresenta tale attività. (Ereditato da AbstractExecutorService)
Submit(IRunnable, Object)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da AbstractExecutorService)
Terminated()	Metodo richiamato quando l'executor ha terminato.
ToArray<T>()	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
IJavaPeerable.Finalized()	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
GetJniTypeName(IJavaPeerable)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
AwaitTerminationAsync(IExecutorService, Int64, TimeUnit)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
InvokeAnyAsync(IExecutorService, ICollection)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.
InvokeAnyAsync(IExecutorService, ICollection, Int64, TimeUnit)	Oggetto `ExecutorService` che esegue ogni attività inviata usando uno dei thread eventualmente in pool, normalmente configurati usando `Executors` i metodi factory.

Si applica a

Condividi tramite