ForkJoinPool Classe

Définition

Espace de noms:

Java.Util.Concurrent

Assembly:

Mono.Android.dll

Pour ExecutorService l’exécution ForkJoinTaskde s.

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

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

Héritage

Object

Object

AbstractExecutorService

ForkJoinPool

Attributs

RegisterAttribute

Remarques

Pour ExecutorService l’exécution ForkJoinTaskde s. A ForkJoinPool fournit le point d’entrée pour les soumissions provenant de non-clientsForkJoinTask , ainsi que les opérations de gestion et de surveillance.

Un ForkJoinPool écart par rapport à d’autres types de ExecutorService tâches principalement en vertu de l’utilisation <de em>work-stealing</em> : tous les threads du pool tentent de rechercher et d’exécuter des tâches soumises au pool et/ou créées par d’autres tâches actives (éventuellement bloquant l’attente du travail si aucun n’existe). Cela permet un traitement efficace lorsque la plupart des tâches génèrent d’autres tâches secondaires (comme le font la plupart ForkJoinTaskdes autres), ainsi que lorsque de nombreuses petites tâches sont soumises au pool à partir de clients externes. En particulier lorsque vous définissez <em>asyncMode</em> sur true dans les constructeurs, ForkJoinPoolil peut également être approprié d’utiliser des tâches de style événement qui ne sont jamais jointes. Tous les threads de travail sont initialisés avec Thread#isDaemon le jeu true.

Une statique #commonPool() est disponible et appropriée pour la plupart des applications. Le pool commun est utilisé par n’importe quel ForkJoinTask qui n’est pas envoyé explicitement à un pool spécifié. L’utilisation du pool commun réduit normalement l’utilisation des ressources (ses threads sont lentement récupérés pendant les périodes de non-utilisation et rétablies lors de l’utilisation ultérieure).

Pour les applications qui nécessitent des pools distincts ou personnalisés, un ForkJoinPool peut être construit avec un niveau de parallélisme cible donné ; par défaut, égal au nombre de processeurs disponibles. Le pool tente de maintenir suffisamment de threads actifs (ou disponibles) en ajoutant, suspendant ou réémettant dynamiquement des threads de travail internes, même si certaines tâches sont bloquées en attendant de joindre d’autres personnes. Toutefois, aucun ajustement de ce type n’est garanti face aux E/S bloquées ou à toute autre synchronisation non managée. L’interface imbriquée ManagedBlocker active l’extension des types de synchronisation prises en charge. Les stratégies par défaut peuvent être remplacées à l’aide d’un constructeur avec des paramètres correspondant à ceux documentés dans la classe ThreadPoolExecutor.

Outre les méthodes de contrôle d’exécution et de cycle de vie, cette classe fournit des méthodes de vérification d’état (par exemple #getStealCount) destinées à faciliter le développement, le réglage et la surveillance des applications de duplication/jointure. En outre, la méthode #toString retourne des indications de l’état du pool sous une forme pratique pour la surveillance informelle.

Comme c’est le cas avec d’autres ExecutorServices, il existe trois méthodes d’exécution de tâches principales résumées dans le tableau suivant. Celles-ci sont conçues pour être utilisées principalement par les clients qui ne sont pas déjà engagés dans les calculs de duplication/jointure dans le pool actuel. Les principales formes de ces méthodes acceptent des instances de ForkJoinTask, mais les formulaires surchargés permettent également l’exécution mixte d’activités simples Runnableou Callablebasées sur des activités. Toutefois, les tâches qui s’exécutent déjà dans un pool doivent normalement utiliser les formulaires au sein du calcul répertoriés dans le tableau, sauf si vous utilisez des tâches de style événement asynchrone qui ne sont pas généralement jointes, auquel cas il existe peu de différence entre les méthodes choisies.

<table class="plain">caption Summary of task execution methods</caption><tr><td/td><>< th scope="col » Call from non-fork/join clients</th th<>scope="col »> Call from within fork/join computations</th></tr tr<<>>th scope="row » style="text-align :left »>> Arrange async execution</th><td><#execute(ForkJoinTask)/td td<>ForkJoinTask#fork/td>><><</Tr><tr>th scope="row » style="text-align :left »> Await and obtain result</th<>td<>#invoke(ForkJoinTask)/td/td>><ForkJoinTask#invoke</td<>/tr tr><<>th scope="row » style="text-align :left »> Arrange exec and obtain Future</th<>td>#submit(ForkJoinTask)</td>>ForkJoinTask#fork< (ForkJoinTasks <em>are</em> Futures)</td></tr<>/table<>

Les paramètres utilisés pour construire le pool commun peuvent être contrôlés en définissant les propriétés système System#getProperty suivantes : <ul><li>java.util.concurrent.ForkJoinPool.common.parallelism - le niveau de parallélisme, un entier <non négatif li>java.util.concurrent.ForkJoinPool.common.threadFactory - le nom de classe d’un .ForkJoinWorkerThreadFactory Le chargeur de classe système ClassLoader#getSystemClassLoader() est utilisé pour charger cette classe. <li>java.util.concurrent.ForkJoinPool.common.exceptionHandler - nom de classe d’un UncaughtExceptionHandler. Le chargeur de classe système ClassLoader#getSystemClassLoader() est utilisé pour charger cette classe. <li>java.util.concurrent.ForkJoinPool.common.maximumSpares : nombre maximal de threads supplémentaires autorisés pour maintenir le parallélisme cible (par défaut 256). </ul> Si aucune fabrique de thread n’est fournie via une propriété système, le pool commun utilise une fabrique qui utilise le chargeur de classe système comme chargeur de classes de threads Thread#getContextClassLoader(). En outre, si un SecurityManager est présent, le pool commun utilise des threads d’approvisionnement d’usine qui n’ont pas Permissions activé.

En cas d’erreur lors de l’établissement de ces paramètres, les paramètres par défaut sont utilisés. Il est possible de désactiver ou de limiter l’utilisation de threads dans le pool commun en définissant la propriété parallélisme sur zéro et/ou en utilisant une fabrique qui peut retourner null. Toutefois, cela peut entraîner l’exécution de tâches non jointes.

<Notes d’implémentation b>:</b> Cette implémentation limite le nombre maximal de threads en cours d’exécution à 32767. Tente de créer des pools dont le nombre maximal est supérieur au nombre maximal.IllegalArgumentException

Cette implémentation rejette les tâches envoyées (autrement dit, en lisant RejectedExecutionException) uniquement lorsque le pool est arrêté ou que les ressources internes ont été épuisées.

Ajouté dans la version 1.7.

Documentation Java pour java.util.concurrent.ForkJoinPool.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par le projet Android Open Source et utilisés en fonction des termes décrits dans la licence d’attribution Creative Commons 2.5.

Constructeurs

ForkJoinPool()	Crée un ForkJoinPool parallélisme égal à java.lang.Runtime#availableProcessors, en utilisant les valeurs par défaut pour tous les autres paramètres (voir #ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(Int32)	Crée un ForkJoinPool niveau de parallélisme indiqué, en utilisant les valeurs par défaut pour tous les autres paramètres (voir #ForkJoinPool(int, ForkJoinWorkerThreadFactory, UncaughtExceptionHandler, boolean, int, int, int, Predicate, long, TimeUnit)).
ForkJoinPool(Int32, ForkJoinPool+IForkJoinWorkerThreadFactory, Thread+IUncaughtExceptionHandler, Boolean)	Crée un ForkJoinPool parallélisme égal à java.lang.Runtime#availableProcessors, en utilisant la fabrique de threads par défaut #defaultForkJoinWorkerThreadFactory, aucun uncaughtExceptionHandler et le mode de traitement LIFO non asynchrone.
ForkJoinPool(Int32, ForkJoinPool+IForkJoinWorkerThreadFactory, Thread+IUncaughtExceptionHandler, Boolean, Int32, Int32, Int32, IPredicate, Int64, TimeUnit)	Pour ExecutorService l’exécution ForkJoinTaskde s.
ForkJoinPool(IntPtr, JniHandleOwnership)	Constructeur utilisé lors de la création de représentations managées d’objets JNI ; appelée par le runtime.

Propriétés

ActiveThreadCount	Retourne une estimation du nombre de threads qui volent ou exécutent actuellement des tâches.
AsyncMode	Retourne true si ce pool utilise le mode de planification de premier entré en premier sorti local pour les tâches dupliqués qui ne sont jamais jointes.
Class	Retourne la classe runtime de ce Object. (Hérité de Object)
CommonPoolParallelism	Retourne le niveau de parallélisme ciblé du pool commun.
DefaultForkJoinWorkerThreadFactory	Crée un forkJoinWorkerThread.
Factory	Retourne la fabrique utilisée pour construire de nouveaux workers.
Handle	Handle de l’instance Android sous-jacente. (Hérité de Object)
HasQueuedSubmissions	Retourne true s’il existe des tâches soumises à ce pool qui n’ont pas encore commencé à s’exécuter.
IsQuiescent	Retourne true si tous les threads de travail sont actuellement inactifs.
IsShutdown	Retourne true si ce pool a été arrêté.
IsTerminated	Retourne true si toutes les tâches se sont terminées après l’arrêt.
IsTerminating	Retourne true si le processus d’arrêt a commencé mais n’est pas encore terminé.
JniIdentityHashCode	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
JniPeerMembers	Pour ExecutorService l’exécution ForkJoinTaskde s.
Parallelism	Retourne le niveau de parallélisme ciblé de ce pool.
PeerReference	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
PoolSize	Retourne le nombre de threads de travail qui ont démarré, mais qui n’ont pas encore été arrêtés.
QueuedSubmissionCount	Retourne une estimation du nombre de tâches soumises à ce pool qui n’ont pas encore commencé à s’exécuter.
QueuedTaskCount	Retourne une estimation du nombre total de tâches actuellement conservées dans des files d’attente par des threads de travail (mais pas les tâches envoyées au pool qui n’ont pas commencé à s’exécuter).
RunningThreadCount	Retourne une estimation du nombre de threads de travail qui ne sont pas bloqués en attente de joindre des tâches ou pour d’autres synchronisations managées.
StealCount	Retourne une estimation du nombre total de tâches terminées qui ont été exécutées par un thread autre que leur submitter.
ThresholdClass	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
ThresholdType	Cette API prend en charge l’infrastructure Mono pour Android et n’est pas destinée à être utilisée directement à partir de votre code.
UncaughtExceptionHandler	Retourne le gestionnaire pour les threads de travail internes qui se terminent en raison d’erreurs irrécupérables rencontrées lors de l’exécution des tâches.

Méthodes

AwaitQuiescence(Int64, TimeUnit)	S’il est appelé par un ForkJoinTask fonctionnant dans ce pool, équivalent en effet à ForkJoinTask#helpQuiesce.
AwaitTermination(Int64, TimeUnit)	Bloque jusqu’à ce que toutes les tâches aient terminé l’exécution après une demande d’arrêt, ou que le délai d’attente se produise, ou que le thread actuel soit interrompu, selon ce qui se produit en premier.
AwaitTerminationAsync(Int64, TimeUnit)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
Clone()	Crée et retourne une copie de cet objet. (Hérité de Object)
CommonPool()	Retourne l’instance de pool commune.
Dispose()	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
Dispose(Boolean)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
DrainTasksTo(ICollection<ForkJoinTask>)	Supprime toutes les tâches non exécutées non exécutées disponibles de la planification des files d’attente et les ajoute à la collection donnée, sans modifier leur état d’exécution.
Equals(Object)	Indique si un autre objet est « égal à » celui-ci. (Hérité de Object)
Execute(ForkJoinTask)	Organise l’exécution (asynchrone) de la tâche donnée.
Execute(IRunnable)
GetHashCode()	Retourne une valeur de code de hachage pour l'objet. (Hérité de Object)
Invoke(ForkJoinTask)	Exécute la tâche donnée, en retournant son résultat à l’achèvement.
InvokeAll(ICollection)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
InvokeAll(ICollection, Int64, TimeUnit)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
InvokeAny(ICollection)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
InvokeAny(ICollection, Int64, TimeUnit)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
JavaFinalize()	Appelé par le garbage collector sur un objet lorsque le garbage collection détermine qu’il n’y a plus de références à l’objet. (Hérité de Object)
ManagedBlock(ForkJoinPool+IManagedBlocker)	Exécute la tâche éventuellement bloquante donnée.
NewTaskFor(ICallable)	Retourne une RunnableFuture tâche pouvant être appelée donnée. (Hérité de AbstractExecutorService)
NewTaskFor(IRunnable, Object)	Retourne une RunnableFuture valeur exécutable et par défaut donnée. (Hérité de AbstractExecutorService)
Notify()	Réveille un thread unique qui attend le moniteur de cet objet. (Hérité de Object)
NotifyAll()	Réveille tous les threads qui attendent le moniteur de cet objet. (Hérité de Object)
PollSubmission()	Supprime et retourne la soumission non exécutée suivante si une soumission est disponible.
SetHandle(IntPtr, JniHandleOwnership)	Définit la propriété Handle. (Hérité de Object)
Shutdown()	Peut-être lance un arrêt ordonné dans lequel les tâches précédemment soumises sont exécutées, mais aucune nouvelle tâche ne sera acceptée.
ShutdownNow()	Peut-être tente d’annuler et/ou d’arrêter toutes les tâches, et de rejeter toutes les tâches envoyées par la suite.
Submit(ForkJoinTask)	Envoie un ForkJoinTask pour l’exécution.
Submit(ICallable)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
Submit(IRunnable)	Envoie une tâche exécutable pour l’exécution et retourne un futur représentant cette tâche. (Hérité de AbstractExecutorService)
Submit(IRunnable, Object)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de AbstractExecutorService)
ToArray<T>()	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
ToString()	Retourne une représentation de chaîne de l'objet. (Hérité de Object)
UnregisterFromRuntime()	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
Wait()	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti par em ou><em>interrompu</em>.<> (Hérité de Object)
Wait(Int64)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)
Wait(Int64, Int32)	Provoque l’attente du thread actuel jusqu’à ce qu’il soit réveillé, généralement en étant <averti< par> em>ou <em>interrompu/em>,< ou jusqu’à ce qu’une certaine quantité de temps réel s’est écoulée. (Hérité de Object)

Implémentations d’interfaces explicites

IJavaPeerable.Disposed()	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
IJavaPeerable.DisposeUnlessReferenced()	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
IJavaPeerable.Finalized()	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
IJavaPeerable.JniManagedPeerState	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Pour ExecutorService l’exécution ForkJoinTaskde s. (Hérité de Object)

Méthodes d’extension

JavaCast<TResult>(IJavaObject)	Effectue une conversion de type vérifiée par le runtime Android.
JavaCast<TResult>(IJavaObject)	Pour ExecutorService l’exécution ForkJoinTaskde s.
GetJniTypeName(IJavaPeerable)	Pour ExecutorService l’exécution ForkJoinTaskde s.
AwaitTerminationAsync(IExecutorService, Int64, TimeUnit)	Pour ExecutorService l’exécution ForkJoinTaskde s.
InvokeAnyAsync(IExecutorService, ICollection)	Pour ExecutorService l’exécution ForkJoinTaskde s.
InvokeAnyAsync(IExecutorService, ICollection, Int64, TimeUnit)	Pour ExecutorService l’exécution ForkJoinTaskde s.