ForkJoinPool Classe

Définition

[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

Propriétés

Méthodes

Implémentations d’interfaces explicites

Méthodes d’extension

S’applique à